diff --git a/keyserver/src/creators/thread-creator.js b/keyserver/src/creators/thread-creator.js
index 6a78afea9..887b98af0 100644
--- a/keyserver/src/creators/thread-creator.js
+++ b/keyserver/src/creators/thread-creator.js
@@ -1,510 +1,509 @@
 // @flow
 
 import invariant from 'invariant';
 
 import bots from 'lib/facts/bots.js';
 import genesis from 'lib/facts/genesis.js';
 import { getRolePermissionBlobs } from 'lib/permissions/thread-permissions.js';
 import {
   generatePendingThreadColor,
   generateRandomColor,
 } from 'lib/shared/color-utils.js';
 import { isInvalidSidebarSource } from 'lib/shared/message-utils.js';
 import { getThreadTypeParentRequirement } from 'lib/shared/thread-utils.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import type { RawMessageInfo, MessageData } from 'lib/types/message-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import {
   threadTypes,
   threadTypeIsCommunityRoot,
 } from 'lib/types/thread-types-enum.js';
 import {
   type ServerNewThreadRequest,
   type NewThreadResponse,
 } from 'lib/types/thread-types.js';
 import type { ServerUpdateInfo } from 'lib/types/update-types.js';
 import type { UserInfos } from 'lib/types/user-types.js';
 import { pushAll } from 'lib/utils/array.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { promiseAll } from 'lib/utils/promises.js';
 import { firstLine } from 'lib/utils/string-utils.js';
 
 import createIDs from './id-creator.js';
 import createMessages from './message-creator.js';
 import { createInitialRolesForNewThread } from './role-creator.js';
 import type { UpdatesForCurrentSession } from './update-creator.js';
 import { dbQuery, SQL } from '../database/database.js';
 import {
   fetchLatestEditMessageContentByID,
   fetchMessageInfoByID,
 } from '../fetchers/message-fetchers.js';
 import {
   determineThreadAncestry,
   personalThreadQuery,
 } from '../fetchers/thread-fetchers.js';
 import {
   checkThreadPermission,
   validateCandidateMembers,
 } from '../fetchers/thread-permission-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 import {
   changeRole,
   recalculateThreadPermissions,
   commitMembershipChangeset,
   getChangesetCommitResultForExistingThread,
   type MembershipChangeset,
 } from '../updaters/thread-permission-updaters.js';
 import { joinThread } from '../updaters/thread-updaters.js';
 import RelationshipChangeset from '../utils/relationship-changeset.js';
 
 const { commbot } = bots;
 
 const privateThreadDescription: string =
   'This is your private chat, ' +
   'where you can set reminders and jot notes in private!';
 
 type CreateThreadOptions = Partial<{
   +forceAddMembers: boolean,
   +updatesForCurrentSession: UpdatesForCurrentSession,
   +silentlyFailMembers: boolean,
 }>;
 
 // If forceAddMembers is set, we will allow the viewer to add random users who
 // they aren't friends with. We will only fail if the viewer is trying to add
 // somebody who they have blocked or has blocked them. On the other hand, if
 // forceAddMembers is not set, we will fail if the viewer tries to add somebody
 // who they aren't friends with and doesn't have a membership row with a
 // nonnegative role for the parent thread.
 async function createThread(
   viewer: Viewer,
   request: ServerNewThreadRequest,
   options?: CreateThreadOptions,
 ): Promise<NewThreadResponse> {
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
 
   const forceAddMembers = options?.forceAddMembers ?? false;
   const updatesForCurrentSession =
     options?.updatesForCurrentSession ?? 'return';
   const silentlyFailMembers = options?.silentlyFailMembers ?? false;
 
   const threadType = request.type;
   const shouldCreateRelationships =
     forceAddMembers || threadType === threadTypes.PERSONAL;
   let parentThreadID = request.parentThreadID ? request.parentThreadID : null;
   const initialMemberIDsFromRequest =
     request.initialMemberIDs && request.initialMemberIDs.length > 0
       ? [...new Set(request.initialMemberIDs)]
       : null;
   const ghostMemberIDsFromRequest =
     request.ghostMemberIDs && request.ghostMemberIDs.length > 0
       ? [...new Set(request.ghostMemberIDs)]
       : null;
 
   const sourceMessageID = request.sourceMessageID
     ? request.sourceMessageID
     : null;
   invariant(
     threadType !== threadTypes.SIDEBAR || sourceMessageID,
     'sourceMessageID should be set for sidebar',
   );
 
   const parentRequirement = getThreadTypeParentRequirement(threadType);
   if (
     (parentRequirement === 'required' && !parentThreadID) ||
     (parentRequirement === 'disabled' && parentThreadID)
   ) {
     throw new ServerError('invalid_parameters');
   }
 
   if (
     threadType === threadTypes.PERSONAL &&
     request.initialMemberIDs?.length !== 1
   ) {
     throw new ServerError('invalid_parameters');
   }
 
   const requestParentThreadID = parentThreadID;
   const confirmParentPermissionPromise = (async () => {
     if (!requestParentThreadID) {
       return;
     }
     const hasParentPermission = await checkThreadPermission(
       viewer,
       requestParentThreadID,
       threadType === threadTypes.SIDEBAR
         ? threadPermissions.CREATE_SIDEBARS
         : threadPermissions.CREATE_SUBCHANNELS,
     );
     if (!hasParentPermission) {
       throw new ServerError('invalid_credentials');
     }
   })();
 
   // This is a temporary hack until we release actual E2E-encrypted local
   // conversations. For now we are hosting all root threads on Ashoat's
   // keyserver, so we set them to the have the Genesis community as their
   // parent thread.
   if (!parentThreadID && !threadTypeIsCommunityRoot(threadType)) {
     parentThreadID = genesis.id;
   }
 
   const determineThreadAncestryPromise = determineThreadAncestry(
     parentThreadID,
     threadType,
   );
 
   const validateMembersPromise = (async () => {
     const threadAncestry = await determineThreadAncestryPromise;
     const defaultRolePermissions = getRolePermissionBlobs(threadType).Members;
     const { initialMemberIDs, ghostMemberIDs } = await validateCandidateMembers(
       viewer,
       {
         initialMemberIDs: initialMemberIDsFromRequest,
         ghostMemberIDs: ghostMemberIDsFromRequest,
       },
       {
         threadType,
         parentThreadID,
         containingThreadID: threadAncestry.containingThreadID,
         defaultRolePermissions,
       },
       { requireRelationship: !shouldCreateRelationships },
     );
     if (
       !silentlyFailMembers &&
       (Number(initialMemberIDs?.length) <
         Number(initialMemberIDsFromRequest?.length) ||
         Number(ghostMemberIDs?.length) <
           Number(ghostMemberIDsFromRequest?.length))
     ) {
       throw new ServerError('invalid_credentials');
     }
     return { initialMemberIDs, ghostMemberIDs };
   })();
 
   const sourceMessagePromise: Promise<?RawMessageInfo> = sourceMessageID
     ? fetchMessageInfoByID(viewer, sourceMessageID)
     : Promise.resolve(undefined);
   const {
     sourceMessage,
     threadAncestry,
     validateMembers: { initialMemberIDs, ghostMemberIDs },
   } = await promiseAll({
     sourceMessage: sourceMessagePromise,
     threadAncestry: determineThreadAncestryPromise,
     validateMembers: validateMembersPromise,
     confirmParentPermission: confirmParentPermissionPromise,
   });
 
   if (sourceMessage && isInvalidSidebarSource(sourceMessage)) {
     throw new ServerError('invalid_parameters');
   }
 
   let { id } = request;
   if (id === null || id === undefined) {
     const ids = await createIDs('threads', 1);
     id = ids[0];
   }
   const newRoles = await createInitialRolesForNewThread(id, threadType);
 
   const name = request.name ? firstLine(request.name) : null;
   const description = request.description ? request.description : null;
   let color = request.color
     ? request.color.toLowerCase()
     : generateRandomColor();
   if (threadType === threadTypes.PERSONAL) {
     color = generatePendingThreadColor([
       ...(request.initialMemberIDs ?? []),
       viewer.id,
     ]);
   }
 
   const time = Date.now();
 
   const row = [
     id,
     threadType,
     name,
     description,
     viewer.userID,
     time,
     color,
     parentThreadID,
     threadAncestry.containingThreadID,
     threadAncestry.community,
     threadAncestry.depth,
     sourceMessageID,
   ];
 
   let existingThreadQuery = null;
   if (threadType === threadTypes.PERSONAL) {
     const otherMemberID = initialMemberIDs?.[0];
     invariant(
       otherMemberID,
       'Other member id should be set for a PERSONAL thread',
     );
     existingThreadQuery = personalThreadQuery(viewer.userID, otherMemberID);
   } else if (sourceMessageID) {
     existingThreadQuery = SQL`
       SELECT t.id
       FROM threads t
       WHERE t.source_message = ${sourceMessageID}
     `;
   }
 
   if (existingThreadQuery) {
     const query = SQL`
       INSERT INTO threads(id, type, name, description, creator, creation_time,
         color, parent_thread_id, containing_thread_id, community, depth,
         source_message)
       SELECT ${row}
       WHERE NOT EXISTS (`;
     query.append(existingThreadQuery).append(SQL`)`);
     const [result] = await dbQuery(query);
 
     if (result.affectedRows === 0) {
       const deleteRoles = SQL`
         DELETE FROM roles
         WHERE id IN (${newRoles.default.id}, ${newRoles.creator.id})
       `;
       const deleteIDs = SQL`
         DELETE FROM ids
         WHERE id IN (${id}, ${newRoles.default.id}, ${newRoles.creator.id})
       `;
       const [[existingThreadResult]] = await Promise.all([
         dbQuery(existingThreadQuery),
         dbQuery(deleteRoles),
         dbQuery(deleteIDs),
       ]);
       invariant(existingThreadResult.length > 0, 'thread should exist');
       const existingThreadID = existingThreadResult[0].id.toString();
 
       invariant(request.calendarQuery, 'calendar query should exist');
       const calendarQuery = {
         ...request.calendarQuery,
         filters: [
           ...request.calendarQuery.filters,
           { type: 'threads', threadIDs: [existingThreadID] },
         ],
       };
 
       let joinUpdateInfos: $ReadOnlyArray<ServerUpdateInfo> = [];
       let userInfos: UserInfos = {};
       let newMessageInfos: $ReadOnlyArray<RawMessageInfo> = [];
       if (threadType !== threadTypes.PERSONAL) {
         const joinThreadResult = await joinThread(viewer, {
           threadID: existingThreadID,
           calendarQuery,
         });
         joinUpdateInfos = joinThreadResult.updatesResult.newUpdates;
         userInfos = joinThreadResult.userInfos;
         newMessageInfos = joinThreadResult.rawMessageInfos;
       }
 
       const { viewerUpdates: newUpdates, userInfos: changesetUserInfos } =
         await getChangesetCommitResultForExistingThread(
           viewer,
           existingThreadID,
           joinUpdateInfos,
           { calendarQuery, updatesForCurrentSession },
         );
       userInfos = { ...userInfos, ...changesetUserInfos };
 
       return {
         newThreadID: existingThreadID,
         updatesResult: {
           newUpdates,
         },
         userInfos,
         newMessageInfos,
       };
     }
   } else {
     const query = SQL`
       INSERT INTO threads(id, type, name, description, creator, creation_time,
         color, parent_thread_id, containing_thread_id, community, depth,
         source_message)
       VALUES ${[row]}
     `;
     await dbQuery(query);
   }
 
   const initialMemberPromise: Promise<?MembershipChangeset> = initialMemberIDs
     ? changeRole(id, initialMemberIDs, null, { setNewMembersToUnread: true })
     : Promise.resolve(undefined);
   const ghostMemberPromise: Promise<?MembershipChangeset> = ghostMemberIDs
     ? changeRole(id, ghostMemberIDs, -1)
     : Promise.resolve(undefined);
 
   const [
     creatorChangeset,
     initialMembersChangeset,
     ghostMembersChangeset,
     recalculatePermissionsChangeset,
   ] = await Promise.all([
     changeRole(id, [viewer.userID], newRoles.creator.id),
     initialMemberPromise,
     ghostMemberPromise,
     recalculateThreadPermissions(id),
   ]);
 
   const {
     membershipRows: creatorMembershipRows,
     relationshipChangeset: creatorRelationshipChangeset,
   } = creatorChangeset;
 
   const {
     membershipRows: recalculateMembershipRows,
     relationshipChangeset: recalculateRelationshipChangeset,
   } = recalculatePermissionsChangeset;
 
   const membershipRows = [
     ...creatorMembershipRows,
     ...recalculateMembershipRows,
   ];
   const relationshipChangeset = new RelationshipChangeset();
   relationshipChangeset.addAll(creatorRelationshipChangeset);
   relationshipChangeset.addAll(recalculateRelationshipChangeset);
 
   if (initialMembersChangeset) {
     const {
       membershipRows: initialMembersMembershipRows,
       relationshipChangeset: initialMembersRelationshipChangeset,
     } = initialMembersChangeset;
     pushAll(membershipRows, initialMembersMembershipRows);
     relationshipChangeset.addAll(initialMembersRelationshipChangeset);
   }
   if (ghostMembersChangeset) {
     const {
       membershipRows: ghostMembersMembershipRows,
       relationshipChangeset: ghostMembersRelationshipChangeset,
     } = ghostMembersChangeset;
     pushAll(membershipRows, ghostMembersMembershipRows);
     relationshipChangeset.addAll(ghostMembersRelationshipChangeset);
   }
 
   const changeset = { membershipRows, relationshipChangeset };
   const { viewerUpdates, userInfos } = await commitMembershipChangeset(
     viewer,
     changeset,
     {
       updatesForCurrentSession,
     },
   );
 
   const initialMemberAndCreatorIDs = initialMemberIDs
     ? [...initialMemberIDs, viewer.userID]
     : [viewer.userID];
   const messageDatas: Array<MessageData> = [];
   if (threadType !== threadTypes.SIDEBAR) {
     messageDatas.push({
       type: messageTypes.CREATE_THREAD,
       threadID: id,
       creatorID: viewer.userID,
       time,
       initialThreadState: {
         type: threadType,
         name,
         parentThreadID,
         color,
         memberIDs: initialMemberAndCreatorIDs,
       },
     });
   } else {
     invariant(parentThreadID, 'parentThreadID should be set for sidebar');
     if (!sourceMessage) {
       throw new ServerError('invalid_parameters');
     }
     invariant(
       sourceMessage.type !== messageTypes.REACTION &&
         sourceMessage.type !== messageTypes.EDIT_MESSAGE &&
         sourceMessage.type !== messageTypes.SIDEBAR_SOURCE &&
         sourceMessage.type !== messageTypes.TOGGLE_PIN,
       'Invalid sidebar source type',
     );
 
     let editedSourceMessage = sourceMessage;
     if (sourceMessageID && sourceMessage.type === messageTypes.TEXT) {
-      const editMessageContent = await fetchLatestEditMessageContentByID(
-        sourceMessageID,
-      );
+      const editMessageContent =
+        await fetchLatestEditMessageContentByID(sourceMessageID);
       if (editMessageContent) {
         editedSourceMessage = {
           ...sourceMessage,
           text: editMessageContent.text,
         };
       }
     }
 
     messageDatas.push(
       {
         type: messageTypes.SIDEBAR_SOURCE,
         threadID: id,
         creatorID: viewer.userID,
         time,
         sourceMessage: editedSourceMessage,
       },
       {
         type: messageTypes.CREATE_SIDEBAR,
         threadID: id,
         creatorID: viewer.userID,
         time,
         sourceMessageAuthorID: sourceMessage.creatorID,
         initialThreadState: {
           name,
           parentThreadID,
           color,
           memberIDs: initialMemberAndCreatorIDs,
         },
       },
     );
   }
 
   if (
     parentThreadID &&
     threadType !== threadTypes.SIDEBAR &&
     (parentThreadID !== genesis.id ||
       threadType === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
       threadType === threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD)
   ) {
     messageDatas.push({
       type: messageTypes.CREATE_SUB_THREAD,
       threadID: parentThreadID,
       creatorID: viewer.userID,
       time,
       childThreadID: id,
     });
   }
   const newMessageInfos = await createMessages(
     viewer,
     messageDatas,
     updatesForCurrentSession,
   );
 
   return {
     newThreadID: id,
     updatesResult: {
       newUpdates: viewerUpdates,
     },
     userInfos,
     newMessageInfos,
   };
 }
 
 function createPrivateThread(viewer: Viewer): Promise<NewThreadResponse> {
   return createThread(
     viewer,
     {
       type: threadTypes.PRIVATE,
       description: privateThreadDescription,
       ghostMemberIDs: [commbot.userID],
     },
     {
       forceAddMembers: true,
     },
   );
 }
 
 export { createThread, createPrivateThread, privateThreadDescription };
diff --git a/keyserver/src/responders/website-responders.js b/keyserver/src/responders/website-responders.js
index 68c60eddd..af908178f 100644
--- a/keyserver/src/responders/website-responders.js
+++ b/keyserver/src/responders/website-responders.js
@@ -1,391 +1,400 @@
 // @flow
 
 import html from 'common-tags/lib/html/index.js';
 import { detect as detectBrowser } from 'detect-browser';
 import type { $Response, $Request } from 'express';
 import fs from 'fs';
 import * as React from 'react';
 // eslint-disable-next-line import/extensions
 import ReactDOMServer from 'react-dom/server';
 import { promisify } from 'util';
 
 import stores from 'lib/facts/stores.js';
 import getTitle from 'web/title/getTitle.js';
 
 import { waitForStream } from '../utils/json-stream.js';
 import {
   getAndAssertKeyserverURLFacts,
   getAppURLFactsFromRequestURL,
   getWebAppURLFacts,
 } from '../utils/urls.js';
 
 const { renderToNodeStream } = ReactDOMServer;
 
 const access = promisify(fs.access);
 const readFile = promisify(fs.readFile);
 
 const googleFontsURL =
   'https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@400;500;600&family=Inter:wght@400;500;600&display=swap';
 const localFontsURL = 'fonts/local-fonts.css';
 async function getFontsURL() {
   try {
     await access(localFontsURL);
     return localFontsURL;
   } catch {
     return googleFontsURL;
   }
 }
 
 type AssetInfo = {
   +jsURL: string,
   +fontsURL: string,
   +cssInclude: string,
   +olmFilename: string,
   +commQueryExecutorFilename: string,
   +opaqueURL: string,
 };
 let assetInfo: ?AssetInfo = null;
 async function getAssetInfo() {
   if (assetInfo) {
     return assetInfo;
   }
   if (process.env.NODE_ENV === 'development') {
     const fontsURL = await getFontsURL();
     assetInfo = {
       jsURL: 'http://localhost:8080/dev.build.js',
       fontsURL,
       cssInclude: '',
       olmFilename: '',
       commQueryExecutorFilename: '',
       opaqueURL: 'http://localhost:8080/opaque-ke.wasm',
     };
     return assetInfo;
   }
   try {
     const manifestString = await readFile('../web/dist/manifest.json', 'utf8');
     const manifest = JSON.parse(manifestString);
     const webworkersManifestString = await readFile(
       '../web/dist/webworkers/manifest.json',
       'utf8',
     );
     const webworkersManifest = JSON.parse(webworkersManifestString);
     assetInfo = {
       jsURL: `compiled/${manifest['browser.js']}`,
       fontsURL: googleFontsURL,
       cssInclude: html`
         <link
           rel="stylesheet"
           type="text/css"
           href="compiled/${manifest['browser.css']}"
         />
       `,
       olmFilename: manifest['olm.wasm'],
       commQueryExecutorFilename: webworkersManifest['comm_query_executor.wasm'],
       opaqueURL: `compiled/${manifest['comm_opaque2_wasm_bg.wasm']}`,
     };
     return assetInfo;
   } catch {
     throw new Error(
       'Could not load manifest.json for web build. ' +
         'Did you forget to run `yarn dev` in the web folder?',
     );
   }
 }
 
 let webpackCompiledRootComponent: ?React.ComponentType<{}> = null;
 async function getWebpackCompiledRootComponentForSSR() {
   if (webpackCompiledRootComponent) {
     return webpackCompiledRootComponent;
   }
   try {
     // $FlowFixMe web/dist doesn't always exist
     const webpackBuild = await import('web/dist/app.build.cjs');
     webpackCompiledRootComponent = webpackBuild.app.default;
     return webpackCompiledRootComponent;
   } catch {
     throw new Error(
       'Could not load app.build.cjs. ' +
         'Did you forget to run `yarn dev` in the web folder?',
     );
   }
 }
 
 function stripLastSlash(input: string): string {
   return input.replace(/\/$/, '');
 }
 
 async function websiteResponder(req: $Request, res: $Response): Promise<void> {
   const { basePath } = getAppURLFactsFromRequestURL(req.originalUrl);
   const baseURL = stripLastSlash(basePath);
 
   const keyserverURLFacts = getAndAssertKeyserverURLFacts();
   const keyserverURL = `${keyserverURLFacts.baseDomain}${stripLastSlash(
     keyserverURLFacts.basePath,
   )}`;
 
   const loadingPromise = getWebpackCompiledRootComponentForSSR();
 
   const assetInfoPromise = getAssetInfo();
   const {
     jsURL,
     fontsURL,
     cssInclude,
     olmFilename,
     opaqueURL,
     commQueryExecutorFilename,
   } = await assetInfoPromise;
 
   // prettier-ignore
   res.write(html`
     <!DOCTYPE html>
     <html lang="en">
       <head>
         <meta charset="utf-8" />
         <title>${getTitle(0)}</title>
         <base href="${basePath}" />
         <link rel="stylesheet" type="text/css" href="${fontsURL}" />
         ${cssInclude}
         <link
           rel="apple-touch-icon"
           sizes="180x180"
           href="apple-touch-icon.png"
         />
         <link
           rel="icon"
           type="image/png"
           sizes="32x32"
           href="favicon-32x32.png"
         />
         <link
           rel="icon"
           type="image/png"
           sizes="16x16"
           href="favicon-16x16.png"
         />
         <link rel="manifest" href="site.webmanifest" />
         <meta name="apple-mobile-web-app-title" content="Comm" />
         <meta name="application-name" content="Comm" />
         <meta name="msapplication-TileColor" content="#b91d47" />
         <meta name="theme-color" content="#b91d47" />
       </head>
       <body>
         <div id="react-root">
   `);
 
   const Loading = await loadingPromise;
   const reactStream = renderToNodeStream(<Loading />);
   reactStream.pipe(res, { end: false });
 
   await waitForStream(reactStream);
   res.end(html`
     </div>
     <script>
           var keyserverURL = "${keyserverURL}";
           var baseURL = "${baseURL}";
           var olmFilename = "${olmFilename}";
           var commQueryExecutorFilename = "${commQueryExecutorFilename}";
           var opaqueURL = "${opaqueURL}";
         </script>
         <script src="${jsURL}"></script>
       </body>
     </html>
   `);
 }
 
 const inviteSecretRegex = /^[a-z0-9]+$/i;
 
 // On native, if this responder is called, it means that the app isn't
 // installed.
 async function inviteResponder(req: $Request, res: $Response): Promise<void> {
   const { secret } = req.params;
   const userAgent = req.get('User-Agent');
   const detectionResult = detectBrowser(userAgent);
   if (detectionResult.os === 'Android OS') {
     const isSecretValid = inviteSecretRegex.test(secret);
     const referrer = isSecretValid
       ? `&referrer=${encodeURIComponent(`utm_source=invite/${secret}`)}`
       : '';
     const redirectUrl = `${stores.googlePlayUrl}${referrer}`;
     res.writeHead(301, {
       Location: redirectUrl,
     });
     res.end();
     return;
   } else if (detectionResult.os !== 'iOS') {
     const urlFacts = getWebAppURLFacts();
     const baseDomain = urlFacts?.baseDomain ?? '';
     const basePath = urlFacts?.basePath ?? '/';
     const redirectUrl = `${baseDomain}${basePath}handle/invite/${secret}`;
     res.writeHead(301, {
       Location: redirectUrl,
     });
     res.end();
     return;
   }
   const fontsURL = await getFontsURL();
   res.end(html`
-    <!DOCTYPE html>
+    <!doctype html>
     <html lang="en">
       <head>
         <meta charset="utf-8" />
         <title>Comm</title>
         <link rel="stylesheet" type="text/css" href="/${fontsURL}" />
         <style>
           * {
             -webkit-font-smoothing: antialiased;
             -moz-osx-font-smoothing: grayscale;
             box-sizing: border-box;
             padding: 0;
             margin: 0;
           }
 
           html {
             height: 100%;
             font-size: 112.5%;
           }
 
           body {
-            font-family: 'Inter', -apple-system, 'Segoe UI', 'Roboto', 'Oxygen',
-              'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+            font-family:
+              'Inter',
+              -apple-system,
+              'Segoe UI',
+              'Roboto',
+              'Oxygen',
+              'Ubuntu',
+              'Cantarell',
+              'Fira Sans',
+              'Droid Sans',
+              'Helvetica Neue',
               ui-sans-serif;
             background: #0a0a0a url('/images/invite_link_background.png')
               no-repeat;
             background-size: cover;
             color: #ffffff;
             display: flex;
             flex-direction: column;
             justify-content: space-around;
             align-items: center;
             height: 100%;
             padding: 1.6rem;
             font-size: 1.8rem;
             line-height: 2.4rem;
             font-weight: 500;
           }
 
           section {
             display: flex;
             flex-direction: column;
             align-items: center;
             justify-content: space-between;
             width: 100%;
           }
 
           .card {
             width: 100%;
             padding: 3.2rem 1.6rem;
             gap: 4rem;
             background-color: #1f1f1f;
             border-radius: 1.6rem;
           }
 
           .buttons {
             gap: 1.2rem;
           }
 
           h1 {
             font-size: 3.6rem;
             line-height: 1.5;
             font-weight: 500;
             font-family: 'IBM Plex Sans', sans-serif;
           }
 
           p {
             text-align: center;
           }
 
           .separator {
             border: 1px solid #404040;
             width: 100%;
           }
 
           .button {
             all: unset;
             box-sizing: border-box;
             display: flex;
             justify-content: center;
             align-items: center;
             width: 100%;
             padding: 1.7rem;
             border-radius: 0.4rem;
             border: 1px solid transparent;
             background-color: #6d49ab;
             font-size: 1.6rem;
             line-height: 1.5;
           }
 
           .button.secondary {
             background-color: #1f1f1f;
             border-color: #ffffff;
           }
 
           .link {
             all: unset;
             box-sizing: border-box;
             display: flex;
             align-items: center;
           }
 
           .link-text {
             text-decoration-line: underline;
           }
 
           .logo-container {
             background-color: #0a0a0a;
             width: 4.2rem;
             height: 4.2rem;
             display: flex;
             justify-content: center;
             align-items: center;
             border-radius: 50%;
           }
 
           .logo {
             height: 2.6rem;
           }
 
           .arrow {
             width: 1.8rem;
             height: 1.8rem;
           }
         </style>
       </head>
       <body>
         <div></div>
         <section class="card">
           <section>
             <div class="logo-container">
               <img
                 src="/images/loading_logo.svg"
                 alt="Comm logo"
                 class="logo"
               />
             </div>
             <h1>Comm</h1>
           </section>
           <p>
             To join this community, download the Comm app and reopen this invite
             link
           </p>
           <div class="separator"></div>
           <section class="buttons">
             <a class="button" href="${stores.appStoreUrl}">Download Comm</a>
             <a class="button secondary" href="comm://invite/${secret}">
               Invite Link
             </a>
           </section>
         </section>
         <a class="link" href="https://comm.app/">
           <span class="link-text">Visit Comm’s website</span>
           <img
             src="/images/arrow_up_right.svg"
             alt="arrow up right"
             class="arrow"
           />
         </a>
       </body>
     </html>
   `);
 }
 
 export { websiteResponder, inviteResponder };
diff --git a/keyserver/src/socket/socket.js b/keyserver/src/socket/socket.js
index ceef95b1b..9a3a64c74 100644
--- a/keyserver/src/socket/socket.js
+++ b/keyserver/src/socket/socket.js
@@ -1,884 +1,883 @@
 // @flow
 
 import type { $Request } from 'express';
 import invariant from 'invariant';
 import _debounce from 'lodash/debounce.js';
 import t from 'tcomb';
 import type { TUnion } from 'tcomb';
 import WebSocket from 'ws';
 
 import { baseLegalPolicies } from 'lib/facts/policies.js';
 import { mostRecentMessageTimestamp } from 'lib/shared/message-utils.js';
 import { isStaff } from 'lib/shared/staff-utils.js';
 import {
   serverRequestSocketTimeout,
   serverResponseTimeout,
 } from 'lib/shared/timeouts.js';
 import { mostRecentUpdateTimestamp } from 'lib/shared/update-utils.js';
 import { hasMinCodeVersion } from 'lib/shared/version-utils.js';
 import { endpointIsSocketSafe } from 'lib/types/endpoints.js';
 import type { RawEntryInfo } from 'lib/types/entry-types.js';
 import { defaultNumberPerThread } from 'lib/types/message-types.js';
 import { redisMessageTypes, type RedisMessage } from 'lib/types/redis-types.js';
 import { serverRequestTypes } from 'lib/types/request-types.js';
 import {
   sessionCheckFrequency,
   stateCheckInactivityActivationInterval,
 } from 'lib/types/session-types.js';
 import {
   type ClientSocketMessage,
   type InitialClientSocketMessage,
   type ResponsesClientSocketMessage,
   type ServerStateSyncFullSocketPayload,
   type ServerServerSocketMessage,
   type ErrorServerSocketMessage,
   type AuthErrorServerSocketMessage,
   type PingClientSocketMessage,
   type AckUpdatesClientSocketMessage,
   type APIRequestClientSocketMessage,
   clientSocketMessageTypes,
   stateSyncPayloadTypes,
   serverSocketMessageTypes,
   serverServerSocketMessageValidator,
 } from 'lib/types/socket-types.js';
 import type { LegacyRawThreadInfos } from 'lib/types/thread-types.js';
 import type { UserInfo, CurrentUserInfo } from 'lib/types/user-types.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { values } from 'lib/utils/objects.js';
 import { promiseAll, ignorePromiseRejections } from 'lib/utils/promises.js';
 import SequentialPromiseResolver from 'lib/utils/sequential-promise-resolver.js';
 import sleep from 'lib/utils/sleep.js';
 import { tShape, tCookie } from 'lib/utils/validation-utils.js';
 
 import { RedisSubscriber } from './redis.js';
 import {
   clientResponseInputValidator,
   processClientResponses,
   initializeSession,
   checkState,
 } from './session-utils.js';
 import { fetchUpdateInfosWithRawUpdateInfos } from '../creators/update-creator.js';
 import { deleteActivityForViewerSession } from '../deleters/activity-deleters.js';
 import { deleteCookie } from '../deleters/cookie-deleters.js';
 import { deleteUpdatesBeforeTimeTargetingSession } from '../deleters/update-deleters.js';
 import { jsonEndpoints } from '../endpoints.js';
 import {
   fetchMessageInfosSince,
   getMessageFetchResultFromRedisMessages,
 } from '../fetchers/message-fetchers.js';
 import { fetchUpdateInfos } from '../fetchers/update-fetchers.js';
 import {
   newEntryQueryInputValidator,
   verifyCalendarQueryThreadIDs,
 } from '../responders/entry-responders.js';
 import {
   fetchViewerForSocket,
   updateCookie,
   isCookieMissingSignedIdentityKeysBlob,
   isCookieMissingOlmNotificationsSession,
   createNewAnonymousCookie,
 } from '../session/cookies.js';
 import { Viewer } from '../session/viewer.js';
 import type { AnonymousViewerData } from '../session/viewer.js';
 import { serverStateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
 import { commitSessionUpdate } from '../updaters/session-updaters.js';
 import { compressMessage } from '../utils/compress.js';
 import { assertSecureRequest } from '../utils/security-utils.js';
 import {
   checkInputValidator,
   checkClientSupported,
   policiesValidator,
   validateOutput,
 } from '../utils/validation-utils.js';
 
 const clientSocketMessageInputValidator: TUnion<ClientSocketMessage> = t.union([
   tShape<InitialClientSocketMessage>({
     type: t.irreducible(
       'clientSocketMessageTypes.INITIAL',
       x => x === clientSocketMessageTypes.INITIAL,
     ),
     id: t.Number,
     payload: tShape({
       sessionIdentification: tShape({
         cookie: t.maybe(tCookie),
         sessionID: t.maybe(t.String),
       }),
       sessionState: tShape({
         calendarQuery: newEntryQueryInputValidator,
         messagesCurrentAsOf: t.Number,
         updatesCurrentAsOf: t.Number,
         watchedIDs: t.list(t.String),
       }),
       clientResponses: t.list(clientResponseInputValidator),
     }),
   }),
   tShape<ResponsesClientSocketMessage>({
     type: t.irreducible(
       'clientSocketMessageTypes.RESPONSES',
       x => x === clientSocketMessageTypes.RESPONSES,
     ),
     id: t.Number,
     payload: tShape({
       clientResponses: t.list(clientResponseInputValidator),
     }),
   }),
   tShape<PingClientSocketMessage>({
     type: t.irreducible(
       'clientSocketMessageTypes.PING',
       x => x === clientSocketMessageTypes.PING,
     ),
     id: t.Number,
   }),
   tShape<AckUpdatesClientSocketMessage>({
     type: t.irreducible(
       'clientSocketMessageTypes.ACK_UPDATES',
       x => x === clientSocketMessageTypes.ACK_UPDATES,
     ),
     id: t.Number,
     payload: tShape({
       currentAsOf: t.Number,
     }),
   }),
   tShape<APIRequestClientSocketMessage>({
     type: t.irreducible(
       'clientSocketMessageTypes.API_REQUEST',
       x => x === clientSocketMessageTypes.API_REQUEST,
     ),
     id: t.Number,
     payload: tShape({
       endpoint: t.String,
       input: t.maybe(t.Object),
     }),
   }),
 ]);
 
 function onConnection(ws: WebSocket, req: $Request) {
   assertSecureRequest(req);
   new Socket(ws, req);
 }
 
 type StateCheckConditions = {
   activityRecentlyOccurred: boolean,
   stateCheckOngoing: boolean,
 };
 
 const minVersionsForCompression = {
   native: 265,
   web: 30,
 };
 
 class Socket {
   ws: WebSocket;
   httpRequest: $Request;
   viewer: ?Viewer;
   redis: ?RedisSubscriber;
   redisPromiseResolver: SequentialPromiseResolver<ServerServerSocketMessage>;
 
   stateCheckConditions: StateCheckConditions = {
     activityRecentlyOccurred: true,
     stateCheckOngoing: false,
   };
   stateCheckTimeoutID: ?TimeoutID;
 
   constructor(ws: WebSocket, httpRequest: $Request) {
     this.ws = ws;
     this.httpRequest = httpRequest;
     ws.on('message', this.onMessage);
     ws.on('close', this.onClose);
     this.resetTimeout();
     this.redisPromiseResolver = new SequentialPromiseResolver(this.sendMessage);
   }
 
   onMessage = async (
     messageString: string | Buffer | ArrayBuffer | Array<Buffer>,
   ): Promise<void> => {
     invariant(typeof messageString === 'string', 'message should be string');
     let clientSocketMessage: ?ClientSocketMessage;
     try {
       this.resetTimeout();
       const messageObject = JSON.parse(messageString);
       clientSocketMessage = checkInputValidator(
         clientSocketMessageInputValidator,
         messageObject,
       );
       if (clientSocketMessage.type === clientSocketMessageTypes.INITIAL) {
         if (this.viewer) {
           // This indicates that the user sent multiple INITIAL messages.
           throw new ServerError('socket_already_initialized');
         }
         this.viewer = await fetchViewerForSocket(
           this.httpRequest,
           clientSocketMessage,
         );
       }
       const { viewer } = this;
       if (!viewer) {
         // This indicates a non-INITIAL message was sent by the client before
         // the INITIAL message.
         throw new ServerError('socket_uninitialized');
       }
       if (viewer.sessionChanged) {
         // This indicates that the cookie was invalid, and we've assigned a new
         // anonymous one.
         throw new ServerError('socket_deauthorized');
       }
       if (!viewer.loggedIn) {
         // This indicates that the specified cookie was an anonymous one.
         throw new ServerError('not_logged_in');
       }
       await checkClientSupported(
         viewer,
         clientSocketMessageInputValidator,
         clientSocketMessage,
       );
       await policiesValidator(viewer, baseLegalPolicies);
 
-      const serverResponses = await this.handleClientSocketMessage(
-        clientSocketMessage,
-      );
+      const serverResponses =
+        await this.handleClientSocketMessage(clientSocketMessage);
       if (!this.redis) {
         this.redis = new RedisSubscriber(
           { userID: viewer.userID, sessionID: viewer.session },
           this.onRedisMessage,
         );
       }
       if (viewer.sessionChanged) {
         // This indicates that something has caused the session to change, which
         // shouldn't happen from inside a WebSocket since we can't handle cookie
         // invalidation.
         throw new ServerError('session_mutated_from_socket');
       }
       if (clientSocketMessage.type !== clientSocketMessageTypes.PING) {
         ignorePromiseRejections(updateCookie(viewer));
       }
       for (const response of serverResponses) {
         // Normally it's an anti-pattern to await in sequence like this. But in
         // this case, we have a requirement that this array of serverResponses
         // is delivered in order. See here:
         // https://github.com/CommE2E/comm/blob/101eb34481deb49c609bfd2c785f375886e52666/keyserver/src/socket/socket.js#L566-L568
         await this.sendMessage(response);
       }
       if (clientSocketMessage.type === clientSocketMessageTypes.INITIAL) {
         this.onSuccessfulConnection();
       }
     } catch (error) {
       console.warn(error);
       if (!(error instanceof ServerError)) {
         const errorMessage: ErrorServerSocketMessage = {
           type: serverSocketMessageTypes.ERROR,
           message: error.message,
         };
         const responseTo = clientSocketMessage ? clientSocketMessage.id : null;
         if (responseTo !== null) {
           errorMessage.responseTo = responseTo;
         }
         this.markActivityOccurred();
         await this.sendMessage(errorMessage);
         return;
       }
       invariant(clientSocketMessage, 'should be set');
       const responseTo = clientSocketMessage.id;
       if (error.message === 'socket_deauthorized') {
         invariant(this.viewer, 'should be set');
         const authErrorMessage: AuthErrorServerSocketMessage = {
           type: serverSocketMessageTypes.AUTH_ERROR,
           responseTo,
           message: error.message,
           sessionChange: {
             cookie: this.viewer.cookiePairString,
             currentUserInfo: {
               anonymous: true,
             },
           },
         };
 
         await this.sendMessage(authErrorMessage);
         this.ws.close(4100, error.message);
         return;
       } else if (error.message === 'client_version_unsupported') {
         const { viewer } = this;
         invariant(viewer, 'should be set');
 
         const anonymousViewerDataPromise: Promise<AnonymousViewerData> =
           createNewAnonymousCookie({
             platformDetails: error.platformDetails,
             deviceToken: viewer.deviceToken,
           });
         const deleteCookiePromise = deleteCookie(viewer.cookieID);
         const [anonymousViewerData] = await Promise.all([
           anonymousViewerDataPromise,
           deleteCookiePromise,
         ]);
 
         // It is normally not safe to pass the result of
         // createNewAnonymousCookie to the Viewer constructor. That is because
         // createNewAnonymousCookie leaves several fields of
         // AnonymousViewerData unset, and consequently Viewer will throw when
         // access is attempted. It is only safe here because we can guarantee
         // that only cookiePairString and cookieID are accessed on anonViewer
         // below.
         const anonViewer = new Viewer(anonymousViewerData);
         const authErrorMessage: AuthErrorServerSocketMessage = {
           type: serverSocketMessageTypes.AUTH_ERROR,
           responseTo,
           message: error.message,
           sessionChange: {
             cookie: anonViewer.cookiePairString,
             currentUserInfo: {
               anonymous: true,
             },
           },
         };
         await this.sendMessage(authErrorMessage);
         this.ws.close(4101, error.message);
         return;
       }
       if (error.payload) {
         await this.sendMessage({
           type: serverSocketMessageTypes.ERROR,
           responseTo,
           message: error.message,
           payload: error.payload,
         });
       } else {
         await this.sendMessage({
           type: serverSocketMessageTypes.ERROR,
           responseTo,
           message: error.message,
         });
       }
       if (error.message === 'not_logged_in') {
         this.ws.close(4102, error.message);
       } else if (error.message === 'session_mutated_from_socket') {
         this.ws.close(4103, error.message);
       } else {
         this.markActivityOccurred();
       }
     }
   };
 
   onClose = async () => {
     this.clearStateCheckTimeout();
     this.resetTimeout.cancel();
     this.debouncedAfterActivity.cancel();
     if (this.viewer && this.viewer.hasSessionInfo) {
       await deleteActivityForViewerSession(this.viewer);
     }
     if (this.redis) {
       this.redis.quit();
       this.redis = null;
     }
   };
 
   sendMessage = async (message: ServerServerSocketMessage) => {
     invariant(
       this.ws.readyState > 0,
       "shouldn't send message until connection established",
     );
     if (this.ws.readyState !== 1) {
       return;
     }
 
     const { viewer } = this;
     const validatedMessage = validateOutput(
       viewer?.platformDetails,
       serverServerSocketMessageValidator,
       message,
     );
     const stringMessage = JSON.stringify(validatedMessage);
 
     if (
       !viewer?.platformDetails ||
       !hasMinCodeVersion(viewer.platformDetails, minVersionsForCompression) ||
       !isStaff(viewer.id)
     ) {
       this.ws.send(stringMessage);
       return;
     }
 
     const compressionResult = await compressMessage(stringMessage);
 
     if (this.ws.readyState !== 1) {
       return;
     }
 
     if (!compressionResult.compressed) {
       this.ws.send(stringMessage);
       return;
     }
 
     const compressedMessage = {
       type: serverSocketMessageTypes.COMPRESSED_MESSAGE,
       payload: compressionResult.result,
     };
 
     const validatedCompressedMessage = validateOutput(
       viewer?.platformDetails,
       serverServerSocketMessageValidator,
       compressedMessage,
     );
     const stringCompressedMessage = JSON.stringify(validatedCompressedMessage);
     this.ws.send(stringCompressedMessage);
   };
 
   async handleClientSocketMessage(
     message: ClientSocketMessage,
   ): Promise<ServerServerSocketMessage[]> {
     const resultPromise: Promise<ServerServerSocketMessage[]> = (async () => {
       if (message.type === clientSocketMessageTypes.INITIAL) {
         this.markActivityOccurred();
         return await this.handleInitialClientSocketMessage(message);
       } else if (message.type === clientSocketMessageTypes.RESPONSES) {
         this.markActivityOccurred();
         return await this.handleResponsesClientSocketMessage(message);
       } else if (message.type === clientSocketMessageTypes.PING) {
         return this.handlePingClientSocketMessage(message);
       } else if (message.type === clientSocketMessageTypes.ACK_UPDATES) {
         this.markActivityOccurred();
         return await this.handleAckUpdatesClientSocketMessage(message);
       } else if (message.type === clientSocketMessageTypes.API_REQUEST) {
         this.markActivityOccurred();
         return await this.handleAPIRequestClientSocketMessage(message);
       }
       return [];
     })();
     const timeoutPromise: Promise<empty> = (async () => {
       await sleep(serverResponseTimeout);
       throw new ServerError('socket_response_timeout');
     })();
     return await Promise.race([resultPromise, timeoutPromise]);
   }
 
   async handleInitialClientSocketMessage(
     message: InitialClientSocketMessage,
   ): Promise<ServerServerSocketMessage[]> {
     const { viewer } = this;
     invariant(viewer, 'should be set');
 
     const responses: Array<ServerServerSocketMessage> = [];
 
     const { sessionState, clientResponses } = message.payload;
     const {
       calendarQuery,
       updatesCurrentAsOf: oldUpdatesCurrentAsOf,
       messagesCurrentAsOf: oldMessagesCurrentAsOf,
       watchedIDs,
     } = sessionState;
     await verifyCalendarQueryThreadIDs(calendarQuery);
 
     const sessionInitializationResult = await initializeSession(
       viewer,
       calendarQuery,
       oldUpdatesCurrentAsOf,
     );
 
     const threadCursors: { [string]: null } = {};
     for (const watchedThreadID of watchedIDs) {
       threadCursors[watchedThreadID] = null;
     }
     const messageSelectionCriteria = {
       threadCursors,
       joinedThreads: true,
       newerThan: oldMessagesCurrentAsOf,
     };
     const [fetchMessagesResult, { serverRequests, activityUpdateResult }] =
       await Promise.all([
         fetchMessageInfosSince(
           viewer,
           messageSelectionCriteria,
           defaultNumberPerThread,
         ),
         processClientResponses(viewer, clientResponses),
       ]);
     const messagesResult = {
       rawMessageInfos: fetchMessagesResult.rawMessageInfos,
       truncationStatuses: fetchMessagesResult.truncationStatuses,
       currentAsOf: mostRecentMessageTimestamp(
         fetchMessagesResult.rawMessageInfos,
         oldMessagesCurrentAsOf,
       ),
     };
 
     const isCookieMissingSignedIdentityKeysBlobPromise =
       isCookieMissingSignedIdentityKeysBlob(viewer.cookieID);
 
     const isCookieMissingOlmNotificationsSessionPromise =
       isCookieMissingOlmNotificationsSession(viewer);
 
     if (!sessionInitializationResult.sessionContinued) {
       const promises: { +[string]: Promise<mixed> } = Object.fromEntries(
         values(serverStateSyncSpecs).map(spec => [
           spec.hashKey,
           spec.fetchFullSocketSyncPayload(viewer, [calendarQuery]),
         ]),
       );
       // We have a type error here because Flow doesn't know spec.hashKey
       const castPromises: {
         +threadInfos: Promise<LegacyRawThreadInfos>,
         +currentUserInfo: Promise<CurrentUserInfo>,
         +entryInfos: Promise<$ReadOnlyArray<RawEntryInfo>>,
         +userInfos: Promise<$ReadOnlyArray<UserInfo>>,
       } = (promises: any);
       const results = await promiseAll(castPromises);
       const payload: ServerStateSyncFullSocketPayload = {
         type: stateSyncPayloadTypes.FULL,
         messagesResult,
         threadInfos: results.threadInfos,
         currentUserInfo: results.currentUserInfo,
         rawEntryInfos: results.entryInfos,
         userInfos: results.userInfos,
         updatesCurrentAsOf: oldUpdatesCurrentAsOf,
       };
       if (viewer.sessionChanged) {
         // If initializeSession encounters,
         // sessionIdentifierTypes.BODY_SESSION_ID but the session
         // is unspecified or expired,
         // it will set a new sessionID and specify viewer.sessionChanged
         const { sessionID } = viewer;
         invariant(
           sessionID !== null && sessionID !== undefined,
           'should be set',
         );
         payload.sessionID = sessionID;
         viewer.sessionChanged = false;
       }
       responses.push({
         type: serverSocketMessageTypes.STATE_SYNC,
         responseTo: message.id,
         payload,
       });
     } else {
       const { sessionUpdate, deltaEntryInfoResult } =
         sessionInitializationResult;
 
       const deleteExpiredUpdatesPromise =
         deleteUpdatesBeforeTimeTargetingSession(viewer, oldUpdatesCurrentAsOf);
       const fetchUpdateResultPromise = fetchUpdateInfos(
         viewer,
         oldUpdatesCurrentAsOf,
         calendarQuery,
       );
       const sessionUpdatePromise = commitSessionUpdate(viewer, sessionUpdate);
       const [fetchUpdateResult] = await Promise.all([
         fetchUpdateResultPromise,
         deleteExpiredUpdatesPromise,
         sessionUpdatePromise,
       ]);
 
       const { updateInfos, userInfos } = fetchUpdateResult;
       const newUpdatesCurrentAsOf = mostRecentUpdateTimestamp(
         [...updateInfos],
         oldUpdatesCurrentAsOf,
       );
       const updatesResult = {
         newUpdates: updateInfos,
         currentAsOf: newUpdatesCurrentAsOf,
       };
 
       responses.push({
         type: serverSocketMessageTypes.STATE_SYNC,
         responseTo: message.id,
         payload: {
           type: stateSyncPayloadTypes.INCREMENTAL,
           messagesResult,
           updatesResult,
           deltaEntryInfos: deltaEntryInfoResult.rawEntryInfos,
           deletedEntryIDs: deltaEntryInfoResult.deletedEntryIDs,
           userInfos: values(userInfos),
         },
       });
     }
 
     const [signedIdentityKeysBlobMissing, olmNotificationsSessionMissing] =
       await Promise.all([
         isCookieMissingSignedIdentityKeysBlobPromise,
         isCookieMissingOlmNotificationsSessionPromise,
       ]);
 
     if (signedIdentityKeysBlobMissing) {
       serverRequests.push({
         type: serverRequestTypes.SIGNED_IDENTITY_KEYS_BLOB,
       });
     }
 
     if (olmNotificationsSessionMissing) {
       serverRequests.push({
         type: serverRequestTypes.INITIAL_NOTIFICATIONS_ENCRYPTED_MESSAGE,
       });
     }
 
     if (serverRequests.length > 0 || clientResponses.length > 0) {
       // We send this message first since the STATE_SYNC triggers the client's
       // connection status to shift to "connected", and we want to make sure the
       // client responses are cleared from Redux before that happens
       responses.unshift({
         type: serverSocketMessageTypes.REQUESTS,
         responseTo: message.id,
         payload: { serverRequests },
       });
     }
 
     if (activityUpdateResult) {
       // Same reason for unshifting as above
       responses.unshift({
         type: serverSocketMessageTypes.ACTIVITY_UPDATE_RESPONSE,
         responseTo: message.id,
         payload: activityUpdateResult,
       });
     }
 
     return responses;
   }
 
   async handleResponsesClientSocketMessage(
     message: ResponsesClientSocketMessage,
   ): Promise<ServerServerSocketMessage[]> {
     const { viewer } = this;
     invariant(viewer, 'should be set');
 
     const { clientResponses } = message.payload;
     const { stateCheckStatus } = await processClientResponses(
       viewer,
       clientResponses,
     );
 
     const serverRequests = [];
     if (stateCheckStatus && stateCheckStatus.status !== 'state_check') {
       const { sessionUpdate, checkStateRequest } = await checkState(
         viewer,
         stateCheckStatus,
       );
       if (sessionUpdate) {
         await commitSessionUpdate(viewer, sessionUpdate);
         this.setStateCheckConditions({ stateCheckOngoing: false });
       }
       if (checkStateRequest) {
         serverRequests.push(checkStateRequest);
       }
     }
 
     // We send a response message regardless of whether we have any requests,
     // since we need to ack the client's responses
     return [
       {
         type: serverSocketMessageTypes.REQUESTS,
         responseTo: message.id,
         payload: { serverRequests },
       },
     ];
   }
 
   handlePingClientSocketMessage(
     message: PingClientSocketMessage,
   ): ServerServerSocketMessage[] {
     return [
       {
         type: serverSocketMessageTypes.PONG,
         responseTo: message.id,
       },
     ];
   }
 
   async handleAckUpdatesClientSocketMessage(
     message: AckUpdatesClientSocketMessage,
   ): Promise<ServerServerSocketMessage[]> {
     const { viewer } = this;
     invariant(viewer, 'should be set');
     const { currentAsOf } = message.payload;
     await Promise.all([
       deleteUpdatesBeforeTimeTargetingSession(viewer, currentAsOf),
       commitSessionUpdate(viewer, { lastUpdate: currentAsOf }),
     ]);
     return [];
   }
 
   async handleAPIRequestClientSocketMessage(
     message: APIRequestClientSocketMessage,
   ): Promise<ServerServerSocketMessage[]> {
     if (!endpointIsSocketSafe(message.payload.endpoint)) {
       throw new ServerError('endpoint_unsafe_for_socket');
     }
     const { viewer } = this;
     invariant(viewer, 'should be set');
     const responder = jsonEndpoints[message.payload.endpoint];
     await policiesValidator(viewer, responder.requiredPolicies);
     const response = await responder.responder(viewer, message.payload.input);
     return [
       {
         type: serverSocketMessageTypes.API_RESPONSE,
         responseTo: message.id,
         payload: response,
       },
     ];
   }
 
   onRedisMessage = async (message: RedisMessage) => {
     try {
       await this.processRedisMessage(message);
     } catch (e) {
       console.warn(e);
     }
   };
 
   async processRedisMessage(message: RedisMessage) {
     if (message.type === redisMessageTypes.START_SUBSCRIPTION) {
       this.ws.terminate();
     } else if (message.type === redisMessageTypes.NEW_UPDATES) {
       const { viewer } = this;
       invariant(viewer, 'should be set');
       if (message.ignoreSession && message.ignoreSession === viewer.session) {
         return;
       }
       const rawUpdateInfos = message.updates;
       this.redisPromiseResolver.add(
         (async () => {
           const { updateInfos, userInfos } =
             await fetchUpdateInfosWithRawUpdateInfos(rawUpdateInfos, {
               viewer,
             });
           if (updateInfos.length === 0) {
             console.warn(
               'could not get any UpdateInfos from redisMessageTypes.NEW_UPDATES',
             );
             return null;
           }
           this.markActivityOccurred();
           return {
             type: serverSocketMessageTypes.UPDATES,
             payload: {
               updatesResult: {
                 currentAsOf: mostRecentUpdateTimestamp([...updateInfos], 0),
                 newUpdates: updateInfos,
               },
               userInfos: values(userInfos),
             },
           };
         })(),
       );
     } else if (message.type === redisMessageTypes.NEW_MESSAGES) {
       const { viewer } = this;
       invariant(viewer, 'should be set');
       const rawMessageInfos = message.messages;
       const messageFetchResult = getMessageFetchResultFromRedisMessages(
         viewer,
         rawMessageInfos,
       );
       if (messageFetchResult.rawMessageInfos.length === 0) {
         console.warn(
           'could not get any rawMessageInfos from ' +
             'redisMessageTypes.NEW_MESSAGES',
         );
         return;
       }
       this.redisPromiseResolver.add(
         (async () => {
           this.markActivityOccurred();
           return {
             type: serverSocketMessageTypes.MESSAGES,
             payload: {
               messagesResult: {
                 rawMessageInfos: messageFetchResult.rawMessageInfos,
                 truncationStatuses: messageFetchResult.truncationStatuses,
                 currentAsOf: mostRecentMessageTimestamp(
                   messageFetchResult.rawMessageInfos,
                   0,
                 ),
               },
             },
           };
         })(),
       );
     }
   }
 
   onSuccessfulConnection() {
     if (this.ws.readyState !== 1) {
       return;
     }
     this.handleStateCheckConditionsUpdate();
   }
 
   // The Socket will timeout by calling this.ws.terminate()
   // serverRequestSocketTimeout milliseconds after the last
   // time resetTimeout is called
   resetTimeout: { +cancel: () => void } & (() => void) = _debounce(
     () => this.ws.terminate(),
     serverRequestSocketTimeout,
   );
 
   debouncedAfterActivity: { +cancel: () => void } & (() => void) = _debounce(
     () => this.setStateCheckConditions({ activityRecentlyOccurred: false }),
     stateCheckInactivityActivationInterval,
   );
 
   markActivityOccurred = () => {
     if (this.ws.readyState !== 1) {
       return;
     }
     this.setStateCheckConditions({ activityRecentlyOccurred: true });
     this.debouncedAfterActivity();
   };
 
   clearStateCheckTimeout() {
     const { stateCheckTimeoutID } = this;
     if (stateCheckTimeoutID) {
       clearTimeout(stateCheckTimeoutID);
       this.stateCheckTimeoutID = null;
     }
   }
 
   setStateCheckConditions(newConditions: Partial<StateCheckConditions>) {
     this.stateCheckConditions = {
       ...this.stateCheckConditions,
       ...newConditions,
     };
     this.handleStateCheckConditionsUpdate();
   }
 
   get stateCheckCanStart(): boolean {
     return Object.values(this.stateCheckConditions).every(cond => !cond);
   }
 
   handleStateCheckConditionsUpdate() {
     if (!this.stateCheckCanStart) {
       this.clearStateCheckTimeout();
       return;
     }
     if (this.stateCheckTimeoutID) {
       return;
     }
     const { viewer } = this;
     if (!viewer) {
       return;
     }
     const timeUntilStateCheck =
       viewer.sessionLastValidated + sessionCheckFrequency - Date.now();
     if (timeUntilStateCheck <= 0) {
       ignorePromiseRejections(this.initiateStateCheck());
     } else {
       this.stateCheckTimeoutID = setTimeout(
         this.initiateStateCheck,
         timeUntilStateCheck,
       );
     }
   }
 
   initiateStateCheck = async () => {
     this.setStateCheckConditions({ stateCheckOngoing: true });
 
     const { viewer } = this;
     invariant(viewer, 'should be set');
 
     const { checkStateRequest } = await checkState(viewer, {
       status: 'state_check',
     });
     invariant(checkStateRequest, 'should be set');
 
     await this.sendMessage({
       type: serverSocketMessageTypes.REQUESTS,
       payload: { serverRequests: [checkStateRequest] },
     });
   };
 }
 
 export { onConnection };
diff --git a/lib/selectors/socket-selectors.js b/lib/selectors/socket-selectors.js
index 832722ca3..96d8a7ca0 100644
--- a/lib/selectors/socket-selectors.js
+++ b/lib/selectors/socket-selectors.js
@@ -1,226 +1,226 @@
 // @flow
 
 import _memoize from 'lodash/memoize.js';
 import { createSelector } from 'reselect';
 
 import {
   updatesCurrentAsOfSelector,
   currentAsOfSelector,
 } from './keyserver-selectors.js';
 import { currentCalendarQuery } from './nav-selectors.js';
 import type { BoundStateSyncSpec } from '../shared/state-sync/state-sync-spec.js';
 import { stateSyncSpecs } from '../shared/state-sync/state-sync-specs.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import type { SignedIdentityKeysBlob } from '../types/crypto-types.js';
 import { type CalendarQuery } from '../types/entry-types.js';
 import type { AppState } from '../types/redux-types.js';
 import type { ClientReportCreationRequest } from '../types/report-types.js';
 import {
   serverRequestTypes,
   type ClientServerRequest,
   type ClientClientResponse,
 } from '../types/request-types.js';
 import type { SessionState } from '../types/session-types.js';
 import type { OneTimeKeyGenerator } from '../types/socket-types.js';
 import { getConfig } from '../utils/config.js';
 import { minimumOneTimeKeysRequired } from '../utils/crypto-utils.js';
 import { values } from '../utils/objects.js';
 
 const queuedReports: (
   state: AppState,
 ) => $ReadOnlyArray<ClientReportCreationRequest> = createSelector(
   (state: AppState) => state.reportStore.queuedReports,
   (
     mainQueuedReports: $ReadOnlyArray<ClientReportCreationRequest>,
   ): $ReadOnlyArray<ClientReportCreationRequest> => mainQueuedReports,
 );
 
 // We pass all selectors specified in stateSyncSpecs and get the resulting
 // BoundStateSyncSpecs in the specs array. We do it so we don't have to
 // modify the selector when we add a new spec.
 type BoundStateSyncSpecs = {
   +specsPerHashKey: { +[string]: BoundStateSyncSpec<mixed, mixed, mixed> },
   +specPerInnerHashKey: { +[string]: BoundStateSyncSpec<mixed, mixed, mixed> },
 };
 const stateSyncSpecSelectors = values(stateSyncSpecs).map(
   spec => spec.selector,
 );
 const boundStateSyncSpecsSelector: AppState => BoundStateSyncSpecs =
   // The FlowFixMe is needed because createSelector types require flow
   // to know the number of subselectors at compile time.
   // $FlowFixMe
   createSelector(stateSyncSpecSelectors, (...specs) => {
     const boundSpecs = (specs: BoundStateSyncSpec<mixed, mixed, mixed>[]);
     // We create a map from `hashKey` to a given spec for easier lookup later
     const specsPerHashKey = Object.fromEntries(
       boundSpecs.map(spec => [spec.hashKey, spec]),
     );
 
     // We do the same for innerHashKey
     const specPerInnerHashKey = Object.fromEntries(
       boundSpecs
         .filter(spec => spec.innerHashSpec?.hashKey)
         .map(spec => [spec.innerHashSpec?.hashKey, spec]),
     );
 
     return { specsPerHashKey, specPerInnerHashKey };
   });
 
 const getClientResponsesSelector: (
   state: AppState,
 ) => (
   calendarActive: boolean,
   oneTimeKeyGenerator: ?OneTimeKeyGenerator,
   getSignedIdentityKeysBlob: () => Promise<SignedIdentityKeysBlob>,
   getInitialNotificationsEncryptedMessage: ?() => Promise<string>,
   serverRequests: $ReadOnlyArray<ClientServerRequest>,
 ) => Promise<$ReadOnlyArray<ClientClientResponse>> = createSelector(
   boundStateSyncSpecsSelector,
   currentCalendarQuery,
   (
     boundStateSyncSpecs: BoundStateSyncSpecs,
     calendarQuery: (calendarActive: boolean) => CalendarQuery,
   ) => {
     return async (
       calendarActive: boolean,
       oneTimeKeyGenerator: ?OneTimeKeyGenerator,
       getSignedIdentityKeysBlob: () => Promise<SignedIdentityKeysBlob>,
       getInitialNotificationsEncryptedMessage: ?() => Promise<string>,
       serverRequests: $ReadOnlyArray<ClientServerRequest>,
     ): Promise<$ReadOnlyArray<ClientClientResponse>> => {
       const clientResponses = [];
       const serverRequestedPlatformDetails = serverRequests.some(
         request => request.type === serverRequestTypes.PLATFORM_DETAILS,
       );
       const { specsPerHashKey, specPerInnerHashKey } = boundStateSyncSpecs;
       for (const serverRequest of serverRequests) {
         if (
           serverRequest.type === serverRequestTypes.PLATFORM &&
           !serverRequestedPlatformDetails
         ) {
           clientResponses.push({
             type: serverRequestTypes.PLATFORM,
             platform: getConfig().platformDetails.platform,
           });
         } else if (serverRequest.type === serverRequestTypes.PLATFORM_DETAILS) {
           clientResponses.push({
             type: serverRequestTypes.PLATFORM_DETAILS,
             platformDetails: getConfig().platformDetails,
           });
         } else if (serverRequest.type === serverRequestTypes.CHECK_STATE) {
           const query = calendarQuery(calendarActive);
 
           const hashResults: { [string]: boolean } = {};
           for (const key in serverRequest.hashesToCheck) {
             const expectedHashValue = serverRequest.hashesToCheck[key];
             let hashValue;
             const [specKey, id] = key.split('|');
             if (id) {
               hashValue = specPerInnerHashKey[specKey]?.getInfoHash(id);
             } else {
               hashValue = specsPerHashKey[specKey]?.getAllInfosHash(query);
             }
 
             // If hashValue values is null then we are still calculating
             // the hashes in the background. In this case we return true
             // to skip this state check. Future state checks (after the hash
             // calculation complete) will be handled normally.
             if (!hashValue) {
               hashResults[key] = true;
             } else {
               hashResults[key] = expectedHashValue === hashValue;
             }
           }
 
           const { failUnmentioned } = serverRequest;
           for (const spec of values(specPerInnerHashKey)) {
             const innerHashKey = spec.innerHashSpec?.hashKey;
             if (!failUnmentioned?.[spec.hashKey] || !innerHashKey) {
               continue;
             }
 
             const ids = spec.getIDs(query);
             if (!ids) {
               continue;
             }
 
             for (const id of ids) {
               const key = `${innerHashKey}|${id}`;
               const hashResult = hashResults[key];
               if (hashResult === null || hashResult === undefined) {
                 hashResults[key] = false;
               }
             }
           }
 
           clientResponses.push({
             type: serverRequestTypes.CHECK_STATE,
             hashResults,
           });
         } else if (
           serverRequest.type === serverRequestTypes.MORE_ONE_TIME_KEYS &&
           oneTimeKeyGenerator
         ) {
           const keys: string[] = [];
           for (let i = 0; i < minimumOneTimeKeysRequired; ++i) {
             keys.push(oneTimeKeyGenerator(i));
           }
           clientResponses.push({
             type: serverRequestTypes.MORE_ONE_TIME_KEYS,
             keys,
           });
         } else if (
           serverRequest.type === serverRequestTypes.SIGNED_IDENTITY_KEYS_BLOB
         ) {
           const signedIdentityKeysBlob = await getSignedIdentityKeysBlob();
           clientResponses.push({
             type: serverRequestTypes.SIGNED_IDENTITY_KEYS_BLOB,
             signedIdentityKeysBlob,
           });
         } else if (
           serverRequest.type ===
             serverRequestTypes.INITIAL_NOTIFICATIONS_ENCRYPTED_MESSAGE &&
           getInitialNotificationsEncryptedMessage
         ) {
           const initialNotificationsEncryptedMessage =
             await getInitialNotificationsEncryptedMessage();
           clientResponses.push({
             type: serverRequestTypes.INITIAL_NOTIFICATIONS_ENCRYPTED_MESSAGE,
             initialNotificationsEncryptedMessage,
           });
         }
       }
       return clientResponses;
     };
   },
 );
 
 const baseSessionStateFuncSelector: (
   keyserverID: string,
 ) => (
   state: AppState,
 ) => (calendarActive: boolean) => SessionState = keyserverID =>
   createSelector(
     currentAsOfSelector(keyserverID),
     updatesCurrentAsOfSelector(keyserverID),
     currentCalendarQuery,
     (
-        messagesCurrentAsOf: number,
-        updatesCurrentAsOf: number,
-        calendarQuery: (calendarActive: boolean) => CalendarQuery,
-      ) =>
+      messagesCurrentAsOf: number,
+      updatesCurrentAsOf: number,
+      calendarQuery: (calendarActive: boolean) => CalendarQuery,
+    ) =>
       (calendarActive: boolean): SessionState => ({
         calendarQuery: calendarQuery(calendarActive),
         messagesCurrentAsOf,
         updatesCurrentAsOf,
         watchedIDs: threadWatcher.getWatchedIDs(),
       }),
   );
 
 const sessionStateFuncSelector: (
   keyserverID: string,
 ) => (state: AppState) => (calendarActive: boolean) => SessionState = _memoize(
   baseSessionStateFuncSelector,
 );
 
 export { queuedReports, getClientResponsesSelector, sessionStateFuncSelector };
diff --git a/lib/shared/message-utils.js b/lib/shared/message-utils.js
index c3bc80a40..9379e92e7 100644
--- a/lib/shared/message-utils.js
+++ b/lib/shared/message-utils.js
@@ -1,748 +1,749 @@
 // @flow
 
 import invariant from 'invariant';
 import _maxBy from 'lodash/fp/maxBy.js';
 import _orderBy from 'lodash/fp/orderBy.js';
 import * as React from 'react';
 
 import { codeBlockRegex, type ParserRules } from './markdown.js';
 import type { CreationSideEffectsFunc } from './messages/message-spec.js';
 import { messageSpecs } from './messages/message-specs.js';
 import { threadIsGroupChat } from './thread-utils.js';
 import { useStringForUser } from '../hooks/ens-cache.js';
 import { contentStringForMediaArray } from '../media/media-utils.js';
 import type { ChatMessageInfoItem } from '../selectors/chat-selectors.js';
 import { threadInfoSelector } from '../selectors/thread-selectors.js';
 import { userIDsToRelativeUserInfos } from '../selectors/user-selectors.js';
 import { type PlatformDetails, isWebPlatform } from '../types/device-types.js';
 import type { Media } from '../types/media-types.js';
 import { messageTypes } from '../types/message-types-enum.js';
 import {
   type MessageInfo,
   type RawMessageInfo,
   type RobotextMessageInfo,
   type RawMultimediaMessageInfo,
   type MessageData,
   type MessageTruncationStatus,
   type MultimediaMessageData,
   type MessageStore,
   type ComposableMessageInfo,
   messageTruncationStatus,
   type RawComposableMessageInfo,
   type ThreadMessageInfo,
 } from '../types/message-types.js';
 import type {
   EditMessageInfo,
   RawEditMessageInfo,
 } from '../types/messages/edit.js';
 import type { ImagesMessageData } from '../types/messages/images.js';
 import type { MediaMessageData } from '../types/messages/media.js';
 import type {
   RawReactionMessageInfo,
   ReactionMessageInfo,
 } from '../types/messages/reaction.js';
 import type { RawThreadInfo, ThreadInfo } from '../types/thread-types.js';
 import type { UserInfos } from '../types/user-types.js';
 import { extractKeyserverIDFromID } from '../utils/action-utils.js';
 import {
   type EntityText,
   ET,
   useEntityTextAsString,
 } from '../utils/entity-text.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 const localIDPrefix = 'local';
 
 const defaultMediaMessageOptions = Object.freeze({});
 
 // Prefers localID
 function messageKey(messageInfo: MessageInfo | RawMessageInfo): string {
   if (messageInfo.localID) {
     return messageInfo.localID;
   }
   invariant(messageInfo.id, 'localID should exist if ID does not');
   return messageInfo.id;
 }
 
 // Prefers serverID
 function messageID(messageInfo: MessageInfo | RawMessageInfo): string {
   if (messageInfo.id) {
     return messageInfo.id;
   }
   invariant(messageInfo.localID, 'localID should exist if ID does not');
   return messageInfo.localID;
 }
 
 function robotextForMessageInfo(
   messageInfo: RobotextMessageInfo,
   threadInfo: ?ThreadInfo,
   parentThreadInfo: ?ThreadInfo,
 ): EntityText {
   const messageSpec = messageSpecs[messageInfo.type];
   invariant(
     messageSpec.robotext,
     `we're not aware of messageType ${messageInfo.type}`,
   );
   return messageSpec.robotext(messageInfo, { threadInfo, parentThreadInfo });
 }
 
 function createMessageInfo(
   rawMessageInfo: RawMessageInfo,
   viewerID: ?string,
   userInfos: UserInfos,
   threadInfos: { +[id: string]: ThreadInfo },
 ): ?MessageInfo {
   const creatorInfo = userInfos[rawMessageInfo.creatorID];
   const creator = {
     id: rawMessageInfo.creatorID,
     username: creatorInfo ? creatorInfo.username : 'anonymous',
     isViewer: rawMessageInfo.creatorID === viewerID,
   };
 
   const createRelativeUserInfos = (userIDs: $ReadOnlyArray<string>) =>
     userIDsToRelativeUserInfos(userIDs, viewerID, userInfos);
   const createMessageInfoFromRaw = (rawInfo: RawMessageInfo) =>
     createMessageInfo(rawInfo, viewerID, userInfos, threadInfos);
 
   const messageSpec = messageSpecs[rawMessageInfo.type];
 
   return messageSpec.createMessageInfo(rawMessageInfo, creator, {
     threadInfos,
     createMessageInfoFromRaw,
     createRelativeUserInfos,
   });
 }
 
 type LengthResult = {
   +local: number,
   +realized: number,
 };
 function findMessageIDMaxLengths(
   messageIDs: $ReadOnlyArray<?string>,
 ): LengthResult {
   const result = {
     local: 0,
     realized: 0,
   };
   for (const id of messageIDs) {
     if (!id) {
       continue;
     }
     if (id.startsWith(localIDPrefix)) {
       result.local = Math.max(result.local, id.length - localIDPrefix.length);
     } else {
       result.realized = Math.max(result.realized, id.length);
     }
   }
   return result;
 }
 
 function extendMessageID(id: ?string, lengths: LengthResult): ?string {
   if (!id) {
     return id;
   }
   if (id.startsWith(localIDPrefix)) {
     const zeroPaddedID = id
       .substr(localIDPrefix.length)
       .padStart(lengths.local, '0');
     return `${localIDPrefix}${zeroPaddedID}`;
   }
   return id.padStart(lengths.realized, '0');
 }
 
 function sortMessageInfoList<T: MessageInfo | RawMessageInfo>(
   messageInfos: $ReadOnlyArray<T>,
 ): T[] {
   const lengths = findMessageIDMaxLengths(
     messageInfos.map(message => message?.id),
   );
   return _orderBy([
     'time',
     (message: T) => extendMessageID(message?.id, lengths),
   ])(['desc', 'desc'])(messageInfos);
 }
 
-const sortMessageIDs: (messages: { +[id: string]: RawMessageInfo }) => (
-  messageIDs: $ReadOnlyArray<string>,
-) => string[] = messages => messageIDs => {
-  const lengths = findMessageIDMaxLengths(messageIDs);
-  return _orderBy([
-    (id: string) => messages[id].time,
-    (id: string) => extendMessageID(id, lengths),
-  ])(['desc', 'desc'])(messageIDs);
-};
+const sortMessageIDs: (messages: {
+  +[id: string]: RawMessageInfo,
+}) => (messageIDs: $ReadOnlyArray<string>) => string[] =
+  messages => messageIDs => {
+    const lengths = findMessageIDMaxLengths(messageIDs);
+    return _orderBy([
+      (id: string) => messages[id].time,
+      (id: string) => extendMessageID(id, lengths),
+    ])(['desc', 'desc'])(messageIDs);
+  };
 
 function rawMessageInfoFromMessageData(
   messageData: MessageData,
   id: ?string,
 ): RawMessageInfo {
   const messageSpec = messageSpecs[messageData.type];
   invariant(
     messageSpec.rawMessageInfoFromMessageData,
     `we're not aware of messageType ${messageData.type}`,
   );
   return messageSpec.rawMessageInfoFromMessageData(messageData, id);
 }
 
 function mostRecentMessageTimestamp(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
   previousTimestamp: number,
 ): number {
   if (messageInfos.length === 0) {
     return previousTimestamp;
   }
   return _maxBy('time')(messageInfos).time;
 }
 
 function usersInMessageInfos(
   messageInfos: $ReadOnlyArray<MessageInfo | RawMessageInfo>,
 ): string[] {
   const userIDs = new Set<string>();
   for (const messageInfo of messageInfos) {
     if (messageInfo.creatorID) {
       userIDs.add(messageInfo.creatorID);
     } else if (messageInfo.creator) {
       userIDs.add(messageInfo.creator.id);
     }
   }
   return [...userIDs];
 }
 
 function combineTruncationStatuses(
   first: MessageTruncationStatus,
   second: ?MessageTruncationStatus,
 ): MessageTruncationStatus {
   if (
     first === messageTruncationStatus.EXHAUSTIVE ||
     second === messageTruncationStatus.EXHAUSTIVE
   ) {
     return messageTruncationStatus.EXHAUSTIVE;
   } else if (
     first === messageTruncationStatus.UNCHANGED &&
     second !== null &&
     second !== undefined
   ) {
     return second;
   } else {
     return first;
   }
 }
 
 function shimUnsupportedRawMessageInfos(
   rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   platformDetails: ?PlatformDetails,
 ): RawMessageInfo[] {
   if (platformDetails && isWebPlatform(platformDetails.platform)) {
     return [...rawMessageInfos];
   }
   return rawMessageInfos.map(rawMessageInfo => {
     const { shimUnsupportedMessageInfo } = messageSpecs[rawMessageInfo.type];
     if (shimUnsupportedMessageInfo) {
       return shimUnsupportedMessageInfo(rawMessageInfo, platformDetails);
     }
     return rawMessageInfo;
   });
 }
 
 type MediaMessageDataCreationInput = {
   +threadID: string,
   +creatorID: string,
   +media: $ReadOnlyArray<Media>,
   +localID?: ?string,
   +time?: ?number,
   +sidebarCreation?: ?boolean,
   ...
 };
 function createMediaMessageData(
   input: MediaMessageDataCreationInput,
   options: {
     +forceMultimediaMessageType?: boolean,
   } = defaultMediaMessageOptions,
 ): MultimediaMessageData {
   let allMediaArePhotos = true;
   const photoMedia = [];
   for (const singleMedia of input.media) {
     if (singleMedia.type !== 'photo') {
       allMediaArePhotos = false;
       break;
     } else {
       photoMedia.push(singleMedia);
     }
   }
 
   const { localID, threadID, creatorID, sidebarCreation } = input;
   const { forceMultimediaMessageType = false } = options;
   const time = input.time ? input.time : Date.now();
   let messageData;
   if (allMediaArePhotos && !forceMultimediaMessageType) {
     messageData = ({
       type: messageTypes.IMAGES,
       threadID,
       creatorID,
       time,
       media: photoMedia,
     }: ImagesMessageData);
     if (localID) {
       messageData = { ...messageData, localID };
     }
     if (sidebarCreation) {
       messageData = { ...messageData, sidebarCreation };
     }
   } else {
     messageData = ({
       type: messageTypes.MULTIMEDIA,
       threadID,
       creatorID,
       time,
       media: input.media,
     }: MediaMessageData);
     if (localID) {
       messageData = { ...messageData, localID };
     }
     if (sidebarCreation) {
       messageData = { ...messageData, sidebarCreation };
     }
   }
   return messageData;
 }
 
 type MediaMessageInfoCreationInput = {
   ...$Exact<MediaMessageDataCreationInput>,
   +id?: ?string,
 };
 function createMediaMessageInfo(
   input: MediaMessageInfoCreationInput,
   options: {
     +forceMultimediaMessageType?: boolean,
   } = defaultMediaMessageOptions,
 ): RawMultimediaMessageInfo {
   const messageData = createMediaMessageData(input, options);
   const createRawMessageInfo =
     messageSpecs[messageData.type].rawMessageInfoFromMessageData;
   invariant(
     createRawMessageInfo,
     'multimedia message spec should have rawMessageInfoFromMessageData',
   );
   const result = createRawMessageInfo(messageData, input.id);
   invariant(
     result.type === messageTypes.MULTIMEDIA ||
       result.type === messageTypes.IMAGES,
     `media messageSpec returned MessageType ${result.type}`,
   );
   return result;
 }
 
 function stripLocalID(
   rawMessageInfo:
     | RawComposableMessageInfo
     | RawReactionMessageInfo
     | RawEditMessageInfo,
 ) {
   const { localID, ...rest } = rawMessageInfo;
   return rest;
 }
 
 function stripLocalIDs(
   input: $ReadOnlyArray<RawMessageInfo>,
 ): RawMessageInfo[] {
   const output = [];
   for (const rawMessageInfo of input) {
     if (rawMessageInfo.localID) {
       invariant(
         rawMessageInfo.id,
         'serverID should be set if localID is being stripped',
       );
       output.push(stripLocalID(rawMessageInfo));
     } else {
       output.push(rawMessageInfo);
     }
   }
   return output;
 }
 
 // Normally we call trim() to remove whitespace at the beginning and end of each
 // message. However, our Markdown parser supports a "codeBlock" format where the
 // user can indent each line to indicate a code block. If we match the
 // corresponding RegEx, we'll only trim whitespace off the end.
 function trimMessage(message: string): string {
   message = message.replace(/^\n*/, '');
   return codeBlockRegex.exec(message) ? message.trimEnd() : message.trim();
 }
 
 function createMessageQuote(message: string): string {
   // add `>` to each line to include empty lines in the quote
   return message.replace(/^/gm, '> ');
 }
 
 function createMessageReply(message: string): string {
   return createMessageQuote(message) + '\n\n';
 }
 
 function getMostRecentNonLocalMessageID(
   threadID: string,
   messageStore: MessageStore,
 ): ?string {
   const thread = messageStore.threads[threadID];
   return thread?.messageIDs.find(id => !id.startsWith(localIDPrefix));
 }
 
 function getOldestNonLocalMessageID(
   threadID: string,
   messageStore: MessageStore,
 ): ?string {
   const thread = messageStore.threads[threadID];
   if (!thread) {
     return thread;
   }
   const { messageIDs } = thread;
   for (let i = messageIDs.length - 1; i >= 0; i--) {
     const id = messageIDs[i];
     if (!id.startsWith(localIDPrefix)) {
       return id;
     }
   }
   return undefined;
 }
 
 function getMessageTitle(
   messageInfo:
     | ComposableMessageInfo
     | RobotextMessageInfo
     | ReactionMessageInfo
     | EditMessageInfo,
   threadInfo: ThreadInfo,
   parentThreadInfo: ?ThreadInfo,
   markdownRules: ParserRules,
 ): EntityText {
   const { messageTitle } = messageSpecs[messageInfo.type];
   if (messageTitle) {
     return messageTitle({ messageInfo, threadInfo, markdownRules });
   }
 
   invariant(
     messageInfo.type !== messageTypes.TEXT &&
       messageInfo.type !== messageTypes.IMAGES &&
       messageInfo.type !== messageTypes.MULTIMEDIA &&
       messageInfo.type !== messageTypes.REACTION &&
       messageInfo.type !== messageTypes.EDIT_MESSAGE,
     'messageTitle can only be auto-generated for RobotextMessageInfo',
   );
   return robotextForMessageInfo(messageInfo, threadInfo, parentThreadInfo);
 }
 
 function mergeThreadMessageInfos(
   first: ThreadMessageInfo,
   second: ThreadMessageInfo,
   messages: { +[id: string]: RawMessageInfo },
 ): ThreadMessageInfo {
   let firstPointer = 0;
   let secondPointer = 0;
   const mergedMessageIDs = [];
   let firstCandidate = first.messageIDs[firstPointer];
   let secondCandidate = second.messageIDs[secondPointer];
   while (firstCandidate !== undefined || secondCandidate !== undefined) {
     if (firstCandidate === undefined) {
       mergedMessageIDs.push(secondCandidate);
       secondPointer++;
     } else if (secondCandidate === undefined) {
       mergedMessageIDs.push(firstCandidate);
       firstPointer++;
     } else if (firstCandidate === secondCandidate) {
       mergedMessageIDs.push(firstCandidate);
       firstPointer++;
       secondPointer++;
     } else {
       const firstMessage = messages[firstCandidate];
       const secondMessage = messages[secondCandidate];
       invariant(
         firstMessage && secondMessage,
         'message in messageIDs not present in MessageStore',
       );
       if (
         (firstMessage.id &&
           secondMessage.id &&
           firstMessage.id === secondMessage.id) ||
         (firstMessage.localID &&
           secondMessage.localID &&
           firstMessage.localID === secondMessage.localID)
       ) {
         mergedMessageIDs.push(firstCandidate);
         firstPointer++;
         secondPointer++;
       } else if (firstMessage.time < secondMessage.time) {
         mergedMessageIDs.push(secondCandidate);
         secondPointer++;
       } else {
         mergedMessageIDs.push(firstCandidate);
         firstPointer++;
       }
     }
     firstCandidate = first.messageIDs[firstPointer];
     secondCandidate = second.messageIDs[secondPointer];
   }
   return {
     messageIDs: mergedMessageIDs,
     startReached: first.startReached && second.startReached,
   };
 }
 
 type MessagePreviewPart = {
   +text: string,
   // unread has highest contrast, followed by primary, followed by secondary
   +style: 'unread' | 'primary' | 'secondary',
 };
 export type MessagePreviewResult = {
   +message: MessagePreviewPart,
   +username: ?MessagePreviewPart,
 };
 function useMessagePreview(
   originalMessageInfo: ?MessageInfo,
   threadInfo: ThreadInfo,
   markdownRules: ParserRules,
 ): ?MessagePreviewResult {
   let messageInfo;
   if (
     originalMessageInfo &&
     originalMessageInfo.type === messageTypes.SIDEBAR_SOURCE
   ) {
     messageInfo = originalMessageInfo.sourceMessage;
   } else {
     messageInfo = originalMessageInfo;
   }
 
   const { parentThreadID } = threadInfo;
   const parentThreadInfo = useSelector(state =>
     parentThreadID ? threadInfoSelector(state)[parentThreadID] : null,
   );
 
   const hasUsername =
     threadIsGroupChat(threadInfo) ||
     threadInfo.name !== '' ||
     messageInfo?.creator.isViewer;
   const shouldDisplayUser =
     messageInfo?.type === messageTypes.TEXT && hasUsername;
 
   const stringForUser = useStringForUser(
     shouldDisplayUser ? messageInfo?.creator : null,
   );
 
   const { unread } = threadInfo.currentUser;
   const username = React.useMemo(() => {
     if (!shouldDisplayUser) {
       return null;
     }
     invariant(
       stringForUser,
       'useStringForUser should only return falsey if pass null or undefined',
     );
     return {
       text: stringForUser,
       style: unread ? 'unread' : 'secondary',
     };
   }, [shouldDisplayUser, stringForUser, unread]);
 
   const messageTitleEntityText = React.useMemo(() => {
     if (!messageInfo) {
       return messageInfo;
     }
     return getMessageTitle(
       messageInfo,
       threadInfo,
       parentThreadInfo,
       markdownRules,
     );
   }, [messageInfo, threadInfo, parentThreadInfo, markdownRules]);
 
   const threadID = threadInfo.id;
   const entityTextToStringParams = React.useMemo(
     () => ({
       threadID,
     }),
     [threadID],
   );
   const messageTitle = useEntityTextAsString(
     messageTitleEntityText,
     entityTextToStringParams,
   );
 
   const isTextMessage = messageInfo?.type === messageTypes.TEXT;
   const message = React.useMemo(() => {
     if (messageTitle === null || messageTitle === undefined) {
       return messageTitle;
     }
 
     let style;
     if (unread) {
       style = 'unread';
     } else if (isTextMessage) {
       style = 'primary';
     } else {
       style = 'secondary';
     }
 
     return { text: messageTitle, style };
   }, [messageTitle, unread, isTextMessage]);
 
   return React.useMemo(() => {
     if (!message) {
       return message;
     }
     return { message, username };
   }, [message, username]);
 }
 
 function useMessageCreationSideEffectsFunc<Info: RawMessageInfo>(
   messageType: $PropertyType<Info, 'type'>,
 ): CreationSideEffectsFunc<Info> {
   const messageSpec = messageSpecs[messageType];
   invariant(messageSpec, `we're not aware of messageType ${messageType}`);
   invariant(
     messageSpec.useCreationSideEffectsFunc,
     `no useCreationSideEffectsFunc in message spec for ${messageType}`,
   );
   return messageSpec.useCreationSideEffectsFunc();
 }
 
 function getPinnedContentFromMessage(targetMessage: RawMessageInfo): string {
   let pinnedContent;
   if (
     targetMessage.type === messageTypes.IMAGES ||
     targetMessage.type === messageTypes.MULTIMEDIA
   ) {
     pinnedContent = contentStringForMediaArray(targetMessage.media);
   } else {
     pinnedContent = 'a message';
   }
 
   return pinnedContent;
 }
 
 function modifyItemForResultScreen(
   item: ChatMessageInfoItem,
 ): ChatMessageInfoItem {
   if (item.messageInfoType === 'composable') {
     return {
       ...item,
       startsConversation: false,
       startsCluster: true,
       endsCluster: true,
       messageInfo: {
         ...item.messageInfo,
         creator: {
           ...item.messageInfo.creator,
           isViewer: false,
         },
       },
     };
   }
   return item;
 }
 
 function constructChangeRoleEntityText(
   affectedUsers: EntityText | string,
   roleName: ?string,
 ): EntityText {
   if (!roleName) {
     return ET`assigned ${affectedUsers} a new role`;
   }
 
   return ET`assigned ${affectedUsers} the "${roleName}" role`;
 }
 
 function useNextLocalID(): string {
   const nextLocalID = useSelector(state => state.nextLocalID);
   return `${localIDPrefix}${nextLocalID}`;
 }
 
 function isInvalidSidebarSource(
   message: RawMessageInfo | MessageInfo,
 ): boolean %checks {
   return (
     (message.type === messageTypes.REACTION ||
       message.type === messageTypes.EDIT_MESSAGE ||
       message.type === messageTypes.SIDEBAR_SOURCE ||
       message.type === messageTypes.TOGGLE_PIN) &&
     !messageSpecs[message.type].canBeSidebarSource
   );
 }
 
 // Prefer checking isInvalidPinSourceForThread below. This function doesn't
 // check whether the user is attempting to pin a SIDEBAR_SOURCE in the context
 // of its parent thread, so it's not suitable for permission checks. We only
 // use it in the message-fetchers.js code where we don't have access to the
 // RawThreadInfo and don't need to do permission checks.
 function isInvalidPinSource(
   messageInfo: RawMessageInfo | MessageInfo,
 ): boolean {
   return !messageSpecs[messageInfo.type].canBePinned;
 }
 
 function isInvalidPinSourceForThread(
   messageInfo: RawMessageInfo | MessageInfo,
   threadInfo: RawThreadInfo | ThreadInfo,
 ): boolean {
   const isValidPinSource = !isInvalidPinSource(messageInfo);
   const isFirstMessageInSidebar = threadInfo.sourceMessageID === messageInfo.id;
   return !isValidPinSource || isFirstMessageInSidebar;
 }
 
 function isUnableToBeRenderedIndependently(
   message: RawMessageInfo | MessageInfo,
 ): boolean {
   return messageSpecs[message.type].canBeRenderedIndependently === false;
 }
 
 function findNewestMessageTimePerKeyserver(
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
 ): { [keyserverID: string]: number } {
   const timePerKeyserver: { [keyserverID: string]: number } = {};
 
   for (const messageInfo of messageInfos) {
     const keyserverID = extractKeyserverIDFromID(messageInfo.threadID);
 
     if (
       !timePerKeyserver[keyserverID] ||
       timePerKeyserver[keyserverID] < messageInfo.time
     ) {
       timePerKeyserver[keyserverID] = messageInfo.time;
     }
   }
 
   return timePerKeyserver;
 }
 
 export {
   localIDPrefix,
   messageKey,
   messageID,
   robotextForMessageInfo,
   createMessageInfo,
   sortMessageInfoList,
   sortMessageIDs,
   rawMessageInfoFromMessageData,
   mostRecentMessageTimestamp,
   usersInMessageInfos,
   combineTruncationStatuses,
   shimUnsupportedRawMessageInfos,
   createMediaMessageData,
   createMediaMessageInfo,
   stripLocalIDs,
   trimMessage,
   createMessageQuote,
   createMessageReply,
   getMostRecentNonLocalMessageID,
   getOldestNonLocalMessageID,
   getMessageTitle,
   mergeThreadMessageInfos,
   useMessagePreview,
   useMessageCreationSideEffectsFunc,
   getPinnedContentFromMessage,
   modifyItemForResultScreen,
   constructChangeRoleEntityText,
   useNextLocalID,
   isInvalidSidebarSource,
   isInvalidPinSource,
   isInvalidPinSourceForThread,
   isUnableToBeRenderedIndependently,
   findNewestMessageTimePerKeyserver,
 };
diff --git a/lib/utils/call-server-endpoint.js b/lib/utils/call-server-endpoint.js
index 2766e7be3..014616adb 100644
--- a/lib/utils/call-server-endpoint.js
+++ b/lib/utils/call-server-endpoint.js
@@ -1,230 +1,229 @@
 // @flow
 
 import _isEqual from 'lodash/fp/isEqual.js';
 
 import { getConfig } from './config.js';
 import {
   ServerError,
   FetchTimeout,
   SocketOffline,
   SocketTimeout,
 } from './errors.js';
 import sleep from './sleep.js';
 import { uploadBlob, type UploadBlob } from './upload-blob.js';
 import { updateLastCommunicatedPlatformDetailsActionType } from '../actions/device-actions.js';
 import { callServerEndpointTimeout } from '../shared/timeouts.js';
 import type { PlatformDetails } from '../types/device-types.js';
 import {
   type Endpoint,
   type SocketAPIHandler,
   endpointIsSocketPreferred,
   endpointIsSocketOnly,
 } from '../types/endpoints.js';
 import { forcePolicyAcknowledgmentActionType } from '../types/policy-types.js';
 import type { Dispatch } from '../types/redux-types.js';
 import type {
   ServerSessionChange,
   ClientSessionChange,
 } from '../types/session-types.js';
 import type { CurrentUserInfo } from '../types/user-types.js';
 
 export type CallServerEndpointOptions = Partial<{
   // null timeout means no timeout, which is the default for uploadBlob
   +timeout: ?number, // in milliseconds
   // getResultInfo will be called right before callServerEndpoint successfully
   // resolves and includes additional information about the request
   +getResultInfo: (resultInfo: CallServerEndpointResultInfo) => mixed,
   +blobUpload: boolean | UploadBlob,
   // the rest (onProgress, abortHandler) only work with blobUpload
   +onProgress: (percent: number) => void,
   // abortHandler will receive an abort function once the upload starts
   +abortHandler: (abort: () => void) => void,
   // Overrides urlPrefix in Redux
   +urlPrefixOverride: string,
 }>;
 
 export type CallServerEndpointResultInfoInterface = 'socket' | 'REST';
 export type CallServerEndpointResultInfo = {
   +interface: CallServerEndpointResultInfoInterface,
 };
 
 export type CallServerEndpointResponse = Partial<{
   +cookieChange: ServerSessionChange,
   +currentUserInfo: CurrentUserInfo,
   +error: string,
   +payload: Object,
 }>;
 
 // You'll notice that this is not the type of the callServerEndpoint
 // function below. This is because the first several parameters to that
 // function get bound in by the helpers in lib/utils/action-utils.js.
 // This type represents the form of the callServerEndpoint function that
 // gets passed to the action function in lib/actions.
 export type CallServerEndpoint = (
   endpoint: Endpoint,
   input: Object,
   options?: ?CallServerEndpointOptions,
 ) => Promise<Object>;
 
 type RequestData = {
   input: { +[key: string]: mixed },
   cookie?: ?string,
   sessionID?: ?string,
   platformDetails?: PlatformDetails,
 };
 
 async function callServerEndpoint(
   cookie: ?string,
   setNewSession: (sessionChange: ClientSessionChange, error: ?string) => void,
   waitIfCookieInvalidated: () => Promise<?CallServerEndpoint>,
   cookieInvalidationRecovery: (
     sessionChange: ClientSessionChange,
   ) => Promise<?CallServerEndpoint>,
   urlPrefix: string,
   sessionID: ?string,
   isSocketConnected: boolean,
   lastCommunicatedPlatformDetails: ?PlatformDetails,
   socketAPIHandler: ?SocketAPIHandler,
   endpoint: Endpoint,
   input: { +[key: string]: mixed },
   dispatch: Dispatch,
   options?: ?CallServerEndpointOptions,
   loggedIn: boolean,
   keyserverID: string,
 ): Promise<Object> {
   const possibleReplacement = await waitIfCookieInvalidated();
   if (possibleReplacement) {
     return await possibleReplacement(endpoint, input, options);
   }
 
   const shouldSendPlatformDetails =
     lastCommunicatedPlatformDetails &&
     !_isEqual(lastCommunicatedPlatformDetails)(getConfig().platformDetails);
 
   if (
     endpointIsSocketPreferred(endpoint) &&
     isSocketConnected &&
     socketAPIHandler &&
     !options?.urlPrefixOverride
   ) {
     try {
       const result = await socketAPIHandler({ endpoint, input });
       options?.getResultInfo?.({ interface: 'socket' });
       return result;
     } catch (e) {
       if (endpointIsSocketOnly(endpoint)) {
         throw e;
       } else if (e instanceof SocketOffline) {
         // nothing
       } else if (e instanceof SocketTimeout) {
         // nothing
       } else {
         throw e;
       }
     }
   }
   if (endpointIsSocketOnly(endpoint)) {
     throw new SocketOffline('socket_offline');
   }
 
   const resolvedURLPrefix = options?.urlPrefixOverride ?? urlPrefix;
   const url = resolvedURLPrefix ? `${resolvedURLPrefix}/${endpoint}` : endpoint;
 
   let json;
   if (options && options.blobUpload) {
     const uploadBlobCallback =
       typeof options.blobUpload === 'function'
         ? options.blobUpload
         : uploadBlob;
     json = await uploadBlobCallback(url, cookie, sessionID, input, options);
   } else {
     const mergedData: RequestData = { input };
     mergedData.cookie = cookie ? cookie : null;
 
     if (getConfig().setSessionIDOnRequest) {
       // We make sure that if setSessionIDOnRequest is true, we never set
       // sessionID to undefined. null has a special meaning here: we cannot
       // consider the cookieID to be a unique session identifier, but we do not
       // have a sessionID to use either. This should only happen when the user
       // is not logged in on web.
       mergedData.sessionID = sessionID ? sessionID : null;
     }
     if (shouldSendPlatformDetails) {
       mergedData.platformDetails = getConfig().platformDetails;
     }
     const callEndpointPromise =
       (async (): Promise<CallServerEndpointResponse> => {
         const response = await fetch(url, {
           method: 'POST',
           // This is necessary to allow cookie headers to get passed down to us
           credentials: 'same-origin',
           body: JSON.stringify(mergedData),
           headers: {
             'Accept': 'application/json',
             'Content-Type': 'application/json',
           },
         });
         const text = await response.text();
         try {
           return JSON.parse(text);
         } catch (e) {
           console.log(text);
           throw e;
         }
       })();
 
     const timeout =
       options && options.timeout ? options.timeout : callServerEndpointTimeout;
     if (!timeout) {
       json = await callEndpointPromise;
     } else {
       const rejectPromise = (async () => {
         await sleep(timeout);
         throw new FetchTimeout(
           `callServerEndpoint timed out call to ${endpoint}`,
           endpoint,
         );
       })();
       json = await Promise.race([callEndpointPromise, rejectPromise]);
     }
   }
 
   const { cookieChange, error, payload, currentUserInfo } = json;
   const sessionChange: ?ServerSessionChange = cookieChange;
   if (sessionChange) {
     const { threadInfos, userInfos, ...rest } = sessionChange;
     const clientSessionChange = rest.cookieInvalidated
       ? rest
       : { cookieInvalidated: false, currentUserInfo, ...rest };
     if (clientSessionChange.cookieInvalidated) {
-      const maybeReplacement = await cookieInvalidationRecovery(
-        clientSessionChange,
-      );
+      const maybeReplacement =
+        await cookieInvalidationRecovery(clientSessionChange);
       if (maybeReplacement) {
         return await maybeReplacement(endpoint, input, options);
       }
     }
     setNewSession(clientSessionChange, error);
   }
 
   if (!error && shouldSendPlatformDetails) {
     dispatch({
       type: updateLastCommunicatedPlatformDetailsActionType,
       payload: { platformDetails: getConfig().platformDetails, keyserverID },
     });
   }
 
   if (error === 'policies_not_accepted' && loggedIn) {
     dispatch({
       type: forcePolicyAcknowledgmentActionType,
       payload,
     });
   }
   if (error) {
     throw new ServerError(error, payload);
   }
   options?.getResultInfo?.({ interface: 'REST' });
   return json;
 }
 
 export default callServerEndpoint;
diff --git a/lib/utils/ens-cache.test.js b/lib/utils/ens-cache.test.js
index 77813a68b..2b0200b5e 100644
--- a/lib/utils/ens-cache.test.js
+++ b/lib/utils/ens-cache.test.js
@@ -1,357 +1,352 @@
 // @flow
 
 import { ethers } from 'ethers';
 
 import { ENSCache } from './ens-cache.js';
 
 const provider = new ethers.providers.AlchemyProvider(
   'goerli',
   process.env.ALCHEMY_API_KEY,
 );
 const ensCache = new ENSCache(provider);
 
 const baseLookupAddress = provider.lookupAddress.bind(provider);
 let timesLookupAddressCalled = 0;
 provider.lookupAddress = (ethAddress: string) => {
   timesLookupAddressCalled++;
   return baseLookupAddress(ethAddress);
 };
 
 const baseResolveName = provider.resolveName.bind(provider);
 let timesResolveNameCalled = 0;
 provider.resolveName = (ensName: string) => {
   timesResolveNameCalled++;
   return baseResolveName(ensName);
 };
 
 const baseGetAvatar = provider.getAvatar.bind(provider);
 let timesGetAvatarCalled = 0;
 provider.getAvatar = (ethAddress: string) => {
   timesGetAvatarCalled++;
   return baseGetAvatar(ethAddress);
 };
 
 if (!process.env.ALCHEMY_API_KEY) {
   // Test only works if we can query blockchain
   console.log(
     'skipped running ENSCache tests because of missing ALCHEMY_API_KEY ' +
       'environmental variable',
   );
 }
 
 const ashoatDotEth = 'ashoat.eth';
 const ashoatAddr = '0x911413ef4127910d79303483f7470d095f399ca9';
 const ashoatAvatar = 'https://ashoat.com/small_searching.png';
 
 const commalphaDotEth = 'commalpha.eth';
 const commalphaEthAddr = '0x727ad7F5134C03e88087a8019b80388b22aaD24d';
 const commalphaEthAvatar =
   'https://gateway.ipfs.io/ipfs/Qmb6CCsr5Hvv1DKr9Yt9ucbaK8Fz9MUP1kW9NTqAJhk7o8';
 
 const commbetaDotEth = 'commbeta.eth';
 const commbetaEthAddr = '0x07124c3b6687e78aec8f13a2312cba72a0bed387';
 const commbetaEthAvatar =
   'data:image/svg+xml;base64,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';
 
 const noENSNameAddr = '0xcF986104d869967381dFfAb3A4127bCe6a404362';
 
 describe('getNameForAddress', () => {
   beforeAll(() => {
     ensCache.clearCache();
   });
   it('should fail to return ashoat.eth if not in cache', async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const ashoatEthResult = ensCache.getCachedNameForAddress(ashoatAddr);
     expect(ashoatEthResult).toBe(undefined);
   });
   it('should return ashoat.eth', async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const ashoatEthResult = await ensCache.getNameForAddress(ashoatAddr);
     expect(ashoatEthResult).toBe(ashoatDotEth);
   });
   it('should return ashoat.eth if in cache', async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const ashoatEthResult = ensCache.getCachedNameForAddress(ashoatAddr);
     expect(ashoatEthResult).toBe(ashoatDotEth);
   });
   it('should have ashoat.eth cached', async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const timesLookupAddressCalledBefore = timesLookupAddressCalled;
     const ashoatEthResult = await ensCache.getNameForAddress(
       ashoatAddr.toUpperCase(),
     );
     expect(ashoatEthResult).toBe(ashoatDotEth);
     expect(timesLookupAddressCalled).toBe(timesLookupAddressCalledBefore);
   });
   it('should dedup simultaneous fetches', async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
 
     ensCache.clearCache();
     const timesLookupAddressCalledBeforeSingleFetch = timesLookupAddressCalled;
     const ashoatEthResult1 = await ensCache.getNameForAddress(ashoatAddr);
     expect(ashoatEthResult1).toBe(ashoatDotEth);
     const timesLookupAddressCalledForSingleFetch =
       timesLookupAddressCalled - timesLookupAddressCalledBeforeSingleFetch;
 
     ensCache.clearCache();
     const timesLookupAddressCalledBeforeDoubleFetch = timesLookupAddressCalled;
     const [ashoatEthResult2, ashoatEthResult3] = await Promise.all([
       ensCache.getNameForAddress(ashoatAddr),
       ensCache.getNameForAddress(ashoatAddr.toUpperCase()),
     ]);
     expect(ashoatEthResult2).toBe(ashoatDotEth);
     expect(ashoatEthResult3).toBe(ashoatDotEth);
     const timesLookupAddressCalledForDoubleFetch =
       timesLookupAddressCalled - timesLookupAddressCalledBeforeDoubleFetch;
 
     expect(timesLookupAddressCalledForDoubleFetch).toBe(
       timesLookupAddressCalledForSingleFetch,
     );
   });
 });
 
 describe('getNamesForAddresses', () => {
   beforeAll(() => {
     ensCache.clearCache();
   });
   it('should fail to return ashoat.eth if not in cache', async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const ashoatEthResult = ensCache.getCachedNameForAddress(ashoatAddr);
     expect(ashoatEthResult).toBe(undefined);
   });
   it('should return ashoat.eth', async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const [ashoatEthResult] = await ensCache.getNamesForAddresses([ashoatAddr]);
     expect(ashoatEthResult).toBe(ashoatDotEth);
   });
   it('should return ashoat.eth if in cache', async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const ashoatEthResult = ensCache.getCachedNameForAddress(ashoatAddr);
     expect(ashoatEthResult).toBe(ashoatDotEth);
   });
   it('should fetch multiple at a time', async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const [ashoatEthResult, commalphaEthResult, commbetaEthResult] =
       await ensCache.getNamesForAddresses([
         ashoatAddr,
         commalphaEthAddr,
         commbetaEthAddr,
       ]);
     expect(ashoatEthResult).toBe(ashoatDotEth);
     expect(commalphaEthResult).toBe(commalphaDotEth);
     expect(commbetaEthResult).toBe(commbetaDotEth);
   });
   it('should dedup simultaneous fetches', async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
 
     ensCache.clearCache();
     const timesLookupAddressCalledBefore = timesLookupAddressCalled;
 
     const [
       [ashoatEthResult1, commalphaEthResult1, commbetaEthResult1],
       ashoatEthResult2,
       commalphaEthResult2,
       commbetaEthResult2,
     ] = await Promise.all([
       ensCache.getNamesForAddresses([
         ashoatAddr,
         commalphaEthAddr,
         commbetaEthAddr,
       ]),
       ensCache.getNameForAddress(ashoatAddr),
       ensCache.getNameForAddress(commalphaEthAddr),
       ensCache.getNameForAddress(commbetaEthAddr),
     ]);
 
     const timesLookupAddressCalledAfter = timesLookupAddressCalled;
     const timesLookupAddressCalledDuringTest =
       timesLookupAddressCalledAfter - timesLookupAddressCalledBefore;
     expect(timesLookupAddressCalledDuringTest).toBe(0);
 
     expect(ashoatEthResult1).toBe(ashoatDotEth);
     expect(commalphaEthResult1).toBe(commalphaDotEth);
     expect(commbetaEthResult1).toBe(commbetaDotEth);
     expect(ashoatEthResult2).toBe(ashoatDotEth);
     expect(commalphaEthResult2).toBe(commalphaDotEth);
     expect(commbetaEthResult2).toBe(commbetaDotEth);
   });
   it('should return undefined if no ENS name', async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const [noNameResult] = await ensCache.getNamesForAddresses([noENSNameAddr]);
     expect(noNameResult).toBe(undefined);
   });
 });
 
 describe('getAddressForName', () => {
   beforeAll(() => {
     ensCache.clearCache();
   });
   it("should fail to return ashoat.eth's address if not in cache", async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const ashoatAddrResult = ensCache.getCachedAddressForName(ashoatDotEth);
     expect(ashoatAddrResult).toBe(undefined);
   });
   it("should return ashoat.eth's address", async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const ashoatAddrResult = await ensCache.getAddressForName(ashoatDotEth);
     expect(ashoatAddrResult).toBe(ashoatAddr);
   });
   it("should return ashoat.eth's address if in cache", async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const ashoatAddrResult = ensCache.getCachedAddressForName(ashoatDotEth);
     expect(ashoatAddrResult).toBe(ashoatAddr);
   });
   it("should have ashoat.eth's address cached", async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const timesResolveNameCalledBefore = timesResolveNameCalled;
     const ashoatAddrResult = await ensCache.getAddressForName(ashoatDotEth);
     expect(ashoatAddrResult).toBe(ashoatAddr);
     expect(timesResolveNameCalled).toBe(timesResolveNameCalledBefore);
   });
   it('should dedup simultaneous fetches', async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
 
     ensCache.clearCache();
     const timesResolveNameCalledBeforeSingleFetch = timesResolveNameCalled;
     const ashoatAddrResult1 = await ensCache.getAddressForName(ashoatDotEth);
     expect(ashoatAddrResult1).toBe(ashoatAddr);
     const timesResolveNameCalledForSingleFetch =
       timesResolveNameCalled - timesResolveNameCalledBeforeSingleFetch;
 
     ensCache.clearCache();
     const timesResolveNameCalledBeforeDoubleFetch = timesResolveNameCalled;
     const [ashoatAddrResult2, ashoatAddrResult3] = await Promise.all([
       ensCache.getAddressForName(ashoatDotEth),
       ensCache.getAddressForName(ashoatDotEth),
     ]);
     expect(ashoatAddrResult2).toBe(ashoatAddr);
     expect(ashoatAddrResult3).toBe(ashoatAddr);
     const timesResolveNamesCalledForDoubleFetch =
       timesResolveNameCalled - timesResolveNameCalledBeforeDoubleFetch;
 
     expect(timesResolveNamesCalledForDoubleFetch).toBe(
       timesResolveNameCalledForSingleFetch,
     );
   });
 });
 
 describe('getAvatarURIForAddress', () => {
   beforeAll(() => {
     ensCache.clearCache();
   });
   it("should fail to return ashoat.eth's avatar if not in cache", async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const ashoatAvatarResult =
       ensCache.getCachedAvatarURIForAddress(ashoatAddr);
     expect(ashoatAvatarResult).toBe(undefined);
   });
   it("should return ashoat.eth's avatar, an HTTP URI pointing to a PNG", async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
-    const ashoatAvatarResult = await ensCache.getAvatarURIForAddress(
-      ashoatAddr,
-    );
+    const ashoatAvatarResult =
+      await ensCache.getAvatarURIForAddress(ashoatAddr);
     expect(ashoatAvatarResult).toBe(ashoatAvatar);
   });
   it("should return ashoat.eth's avatar if in cache", async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const ashoatAvatarResult =
       ensCache.getCachedAvatarURIForAddress(ashoatAddr);
     expect(ashoatAvatarResult).toBe(ashoatAvatar);
   });
   it("should have ashoat.eth's avatar cached", async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
     const timesGetAvatarCalledBefore = timesGetAvatarCalled;
-    const ashoatAvatarResult = await ensCache.getAvatarURIForAddress(
-      ashoatAddr,
-    );
+    const ashoatAvatarResult =
+      await ensCache.getAvatarURIForAddress(ashoatAddr);
     expect(ashoatAvatarResult).toBe(ashoatAvatar);
     expect(timesGetAvatarCalled).toBe(timesGetAvatarCalledBefore);
   });
   it('should dedup simultaneous fetches', async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
 
     ensCache.clearCache();
     const timesGetAvatarCalledBeforeSingleFetch = timesGetAvatarCalled;
-    const ashoatAvatarResult1 = await ensCache.getAvatarURIForAddress(
-      ashoatAddr,
-    );
+    const ashoatAvatarResult1 =
+      await ensCache.getAvatarURIForAddress(ashoatAddr);
     expect(ashoatAvatarResult1).toBe(ashoatAvatar);
     const timesGetAvatarCalledForSingleFetch =
       timesGetAvatarCalled - timesGetAvatarCalledBeforeSingleFetch;
 
     ensCache.clearCache();
     const timesGetAvatarCalledBeforeDoubleFetch = timesGetAvatarCalled;
     const [ashoatAvatarResult2, ashoatAvatarResult3] = await Promise.all([
       ensCache.getAvatarURIForAddress(ashoatAddr),
       ensCache.getAvatarURIForAddress(ashoatAddr),
     ]);
     expect(ashoatAvatarResult2).toBe(ashoatAvatar);
     expect(ashoatAvatarResult3).toBe(ashoatAvatar);
     const timesGetAvatarCalledForDoubleFetch =
       timesGetAvatarCalled - timesGetAvatarCalledBeforeDoubleFetch;
 
     expect(timesGetAvatarCalledForDoubleFetch).toBe(
       timesGetAvatarCalledForSingleFetch,
     );
   });
   it("should return commalpha.eth's avatar, an IPFS URI pointing to a JPEG", async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
-    const commalphaAvatarResult = await ensCache.getAvatarURIForAddress(
-      commalphaEthAddr,
-    );
+    const commalphaAvatarResult =
+      await ensCache.getAvatarURIForAddress(commalphaEthAddr);
     expect(commalphaAvatarResult).toBe(commalphaEthAvatar);
   });
   it("should return commbeta.eth's avatar, an eip155:1/erc721 URI pointing to an NFT with an SVG data URI", async () => {
     if (!process.env.ALCHEMY_API_KEY) {
       return;
     }
-    const commbetaAvatarResult = await ensCache.getAvatarURIForAddress(
-      commbetaEthAddr,
-    );
+    const commbetaAvatarResult =
+      await ensCache.getAvatarURIForAddress(commbetaEthAddr);
     expect(commbetaAvatarResult).toBe(commbetaEthAvatar);
   });
 });
diff --git a/lib/utils/message-ops-utils.js b/lib/utils/message-ops-utils.js
index 425810d07..95b682ec7 100644
--- a/lib/utils/message-ops-utils.js
+++ b/lib/utils/message-ops-utils.js
@@ -1,298 +1,298 @@
 // @flow
 
 import _keyBy from 'lodash/fp/keyBy.js';
 
 import {
   contentStringForMediaArray,
   encryptedMediaBlobURI,
   encryptedVideoThumbnailBlobURI,
 } from '../media/media-utils.js';
 import { messageID } from '../shared/message-utils.js';
 import { messageSpecs } from '../shared/messages/message-specs.js';
 import type {
   EncryptedVideo,
   Media,
   ClientDBMediaInfo,
   Image,
   Video,
 } from '../types/media-types';
 import {
   messageTypes,
   assertMessageType,
 } from '../types/message-types-enum.js';
 import {
   type ClientDBMessageInfo,
   type RawMessageInfo,
   type ClientDBThreadMessageInfo,
   type ThreadMessageInfo,
 } from '../types/message-types.js';
 import type { MediaMessageServerDBContent } from '../types/messages/media.js';
 
 function translateMediaToClientDBMediaInfos(
   media: $ReadOnlyArray<Media>,
 ): $ReadOnlyArray<ClientDBMediaInfo> {
   const clientDBMediaInfos = [];
   for (const m of media) {
     const type =
       m.type === 'encrypted_photo'
         ? 'photo'
         : m.type === 'encrypted_video'
-        ? 'video'
-        : m.type;
+          ? 'video'
+          : m.type;
 
     const mediaURI =
       m.type === 'encrypted_photo' || m.type === 'encrypted_video'
         ? encryptedMediaBlobURI(m)
         : m.uri;
     clientDBMediaInfos.push({
       id: m.id,
       uri: mediaURI,
       type: type,
       extras: JSON.stringify({
         dimensions: m.dimensions,
         loop: type === 'video' ? m.loop : false,
         local_media_selection: m.localMediaSelection,
         encryption_key: m.encryptionKey,
         thumb_hash: m.thumbHash ?? undefined,
       }),
     });
     if (m.type === 'video' || m.type === 'encrypted_video') {
       const thumbnailURI =
         m.type === 'encrypted_video'
           ? encryptedVideoThumbnailBlobURI(m)
           : m.thumbnailURI;
       clientDBMediaInfos.push({
         id: m.thumbnailID,
         uri: thumbnailURI,
         type: 'photo',
         extras: JSON.stringify({
           dimensions: m.dimensions,
           loop: false,
           encryption_key: m.thumbnailEncryptionKey,
           thumb_hash: m.thumbnailThumbHash ?? undefined,
         }),
       });
     }
   }
   return clientDBMediaInfos;
 }
 
 function translateClientDBMediaInfoToImage(
   clientDBMediaInfo: ClientDBMediaInfo,
 ): Image {
   const { dimensions, local_media_selection, thumb_hash } = JSON.parse(
     clientDBMediaInfo.extras,
   );
 
   if (!local_media_selection) {
     return {
       id: clientDBMediaInfo.id,
       uri: clientDBMediaInfo.uri,
       type: 'photo',
       dimensions: dimensions,
       thumbHash: thumb_hash,
     };
   }
   return {
     id: clientDBMediaInfo.id,
     uri: clientDBMediaInfo.uri,
     type: 'photo',
     dimensions: dimensions,
     localMediaSelection: local_media_selection,
     thumbHash: thumb_hash,
   };
 }
 
 function translateClientDBMediaInfosToMedia(
   clientDBMessageInfo: ClientDBMessageInfo,
 ): $ReadOnlyArray<Media> {
   if (parseInt(clientDBMessageInfo.type) === messageTypes.IMAGES) {
     if (!clientDBMessageInfo.media_infos) {
       return [];
     }
     return clientDBMessageInfo.media_infos.map(
       translateClientDBMediaInfoToImage,
     );
   }
   if (
     !clientDBMessageInfo.media_infos ||
     clientDBMessageInfo.media_infos.length === 0
   ) {
     return [];
   }
   const mediaInfos: $ReadOnlyArray<ClientDBMediaInfo> =
     clientDBMessageInfo.media_infos;
   const mediaMap = _keyBy('id')(mediaInfos);
 
   if (!clientDBMessageInfo.content) {
     return [];
   }
   const messageContent: $ReadOnlyArray<MediaMessageServerDBContent> =
     JSON.parse(clientDBMessageInfo.content);
 
   const translatedMedia: Media[] = [];
   for (const media of messageContent) {
     if (media.type === 'photo') {
       const extras = JSON.parse(mediaMap[media.uploadID].extras);
       const {
         dimensions,
         encryption_key: encryptionKey,
         thumb_hash: thumbHash,
       } = extras;
 
       let image;
       if (encryptionKey) {
         image = {
           id: media.uploadID,
           type: 'encrypted_photo',
           blobURI: mediaMap[media.uploadID].uri,
           dimensions,
           encryptionKey,
           thumbHash,
         };
       } else {
         image = {
           id: media.uploadID,
           type: 'photo',
           uri: mediaMap[media.uploadID].uri,
           dimensions,
           thumbHash,
         };
       }
       translatedMedia.push(image);
     } else if (media.type === 'video') {
       const extras = JSON.parse(mediaMap[media.uploadID].extras);
       const {
         dimensions,
         loop,
         local_media_selection: localMediaSelection,
         encryption_key: encryptionKey,
       } = extras;
 
       const {
         encryption_key: thumbnailEncryptionKey,
         thumb_hash: thumbnailThumbHash,
       } = JSON.parse(mediaMap[media.thumbnailUploadID].extras);
       if (encryptionKey) {
         const video: EncryptedVideo = {
           id: media.uploadID,
           type: 'encrypted_video',
           blobURI: mediaMap[media.uploadID].uri,
           dimensions,
           loop,
           encryptionKey,
           thumbnailID: media.thumbnailUploadID,
           thumbnailBlobURI: mediaMap[media.thumbnailUploadID].uri,
           thumbnailEncryptionKey,
           thumbnailThumbHash,
         };
         translatedMedia.push(video);
       } else {
         const video: Video = {
           id: media.uploadID,
           uri: mediaMap[media.uploadID].uri,
           type: 'video',
           dimensions,
           loop,
           thumbnailID: media.thumbnailUploadID,
           thumbnailURI: mediaMap[media.thumbnailUploadID].uri,
           thumbnailThumbHash,
         };
         translatedMedia.push(
           localMediaSelection ? { ...video, localMediaSelection } : video,
         );
       }
     }
   }
   return translatedMedia;
 }
 
 function translateRawMessageInfoToClientDBMessageInfo(
   rawMessageInfo: RawMessageInfo,
 ): ClientDBMessageInfo {
   return {
     id: messageID(rawMessageInfo),
     local_id: rawMessageInfo.localID ? rawMessageInfo.localID : null,
     thread: rawMessageInfo.threadID,
     user: rawMessageInfo.creatorID,
     type: rawMessageInfo.type.toString(),
     future_type:
       rawMessageInfo.type === messageTypes.UNSUPPORTED
         ? rawMessageInfo.unsupportedMessageInfo.type.toString()
         : null,
     time: rawMessageInfo.time.toString(),
     content:
       messageSpecs[rawMessageInfo.type].messageContentForClientDB?.(
         rawMessageInfo,
       ),
     media_infos:
       rawMessageInfo.type === messageTypes.IMAGES ||
       rawMessageInfo.type === messageTypes.MULTIMEDIA
         ? translateMediaToClientDBMediaInfos(rawMessageInfo.media)
         : null,
   };
 }
 
 function translateClientDBMessageInfoToRawMessageInfo(
   clientDBMessageInfo: ClientDBMessageInfo,
 ): RawMessageInfo {
   return messageSpecs[
     assertMessageType(parseInt(clientDBMessageInfo.type))
   ].rawMessageInfoFromClientDB(clientDBMessageInfo);
 }
 
 type TranslatedThreadMessageInfo = {
   +startReached: boolean,
 };
 export type TranslatedThreadMessageInfos = {
   +[threadID: string]: TranslatedThreadMessageInfo,
 };
 function translateClientDBThreadMessageInfos(
   clientDBThreadMessageInfo: $ReadOnlyArray<ClientDBThreadMessageInfo>,
 ): TranslatedThreadMessageInfos {
   return Object.fromEntries(
     clientDBThreadMessageInfo.map((threadInfo: ClientDBThreadMessageInfo) => [
       threadInfo.id,
       {
         startReached: threadInfo.start_reached === '1',
       },
     ]),
   );
 }
 
 function translateThreadMessageInfoToClientDBThreadMessageInfo(
   id: string,
   threadMessageInfo: ThreadMessageInfo | TranslatedThreadMessageInfo,
 ): ClientDBThreadMessageInfo {
   const startReached = threadMessageInfo.startReached ? 1 : 0;
 
   return {
     id,
     start_reached: startReached.toString(),
   };
 }
 
 function getPinnedContentFromClientDBMessageInfo(
   clientDBMessageInfo: ClientDBMessageInfo,
 ): string {
   const { media_infos } = clientDBMessageInfo;
 
   let pinnedContent;
   if (!media_infos || media_infos.length === 0) {
     pinnedContent = 'a message';
   } else {
     const media = translateClientDBMediaInfosToMedia(clientDBMessageInfo);
     pinnedContent = contentStringForMediaArray(media);
   }
   return pinnedContent;
 }
 
 export {
   translateClientDBMediaInfoToImage,
   translateRawMessageInfoToClientDBMessageInfo,
   translateClientDBMessageInfoToRawMessageInfo,
   translateClientDBMediaInfosToMedia,
   getPinnedContentFromClientDBMessageInfo,
   translateClientDBThreadMessageInfos,
   translateThreadMessageInfoToClientDBThreadMessageInfo,
 };
diff --git a/native/chat/thread-list-modal.react.js b/native/chat/thread-list-modal.react.js
index 6911eac40..8e8b4d406 100644
--- a/native/chat/thread-list-modal.react.js
+++ b/native/chat/thread-list-modal.react.js
@@ -1,198 +1,196 @@
 // @flow
 
 import { useNavigation } from '@react-navigation/native';
 import * as React from 'react';
 import {
   Text,
   TextInput,
   FlatList,
   View,
   TouchableOpacity,
 } from 'react-native';
 
 import type { ThreadSearchState } from 'lib/hooks/search-threads.js';
 import type { ChatThreadItem } from 'lib/selectors/chat-selectors.js';
 import type { SetState } from 'lib/types/hook-types.js';
 import type { SidebarInfo, ThreadInfo } from 'lib/types/thread-types.js';
 
 import { useNavigateToThread } from './message-list-types.js';
 import Modal from '../components/modal.react.js';
 import Search from '../components/search.react.js';
 import SWMansionIcon from '../components/swmansion-icon.react.js';
 import ThreadPill from '../components/thread-pill.react.js';
 import { useIndicatorStyle, useStyles } from '../themes/colors.js';
 import { waitForModalInputFocus } from '../utils/timers.js';
 
 function keyExtractor(sidebarInfo: SidebarInfo | ChatThreadItem) {
   return sidebarInfo.threadInfo.id;
 }
 function getItemLayout(
   data: ?$ReadOnlyArray<SidebarInfo | ChatThreadItem>,
   index: number,
 ) {
   return { length: 24, offset: 24 * index, index };
 }
 
 type Props<U> = {
   +threadInfo: ThreadInfo,
-  +createRenderItem: (onPressItem: (threadInfo: ThreadInfo) => void) => (row: {
-    +item: U,
-    +index: number,
-    ...
-  }) => React.Node,
+  +createRenderItem: (
+    onPressItem: (threadInfo: ThreadInfo) => void,
+  ) => (row: { +item: U, +index: number, ... }) => React.Node,
   +listData: $ReadOnlyArray<U>,
   +searchState: ThreadSearchState,
   +setSearchState: SetState<ThreadSearchState>,
   +onChangeSearchInputText: (text: string) => mixed,
   +searchPlaceholder?: string,
   +modalTitle: string,
 };
 function ThreadListModal<U: SidebarInfo | ChatThreadItem>(
   props: Props<U>,
 ): React.Node {
   const {
     threadInfo: parentThreadInfo,
     searchState,
     setSearchState,
     onChangeSearchInputText,
     listData,
     createRenderItem,
     searchPlaceholder,
     modalTitle,
   } = props;
 
   const searchTextInputRef =
     React.useRef<?React.ElementRef<typeof TextInput>>();
   const setSearchTextInputRef = React.useCallback(
     async (textInput: ?React.ElementRef<typeof TextInput>) => {
       searchTextInputRef.current = textInput;
       if (!textInput) {
         return;
       }
       await waitForModalInputFocus();
       if (searchTextInputRef.current) {
         searchTextInputRef.current.focus();
       }
     },
     [],
   );
 
   const navigateToThread = useNavigateToThread();
   const onPressItem = React.useCallback(
     (threadInfo: ThreadInfo) => {
       setSearchState({
         text: '',
         results: new Set(),
       });
       if (searchTextInputRef.current) {
         searchTextInputRef.current.blur();
       }
       navigateToThread({ threadInfo });
     },
     [navigateToThread, setSearchState],
   );
 
   const renderItem = React.useMemo(
     () => createRenderItem(onPressItem),
     [createRenderItem, onPressItem],
   );
 
   const styles = useStyles(unboundStyles);
   const indicatorStyle = useIndicatorStyle();
   const navigation = useNavigation();
 
   return (
     <Modal modalStyle={styles.modal}>
       <View style={styles.header}>
         <View style={styles.headerTopRow}>
           <Text style={styles.title}>{modalTitle}</Text>
           <TouchableOpacity
             onPress={navigation.goBack}
             style={styles.closeButton}
           >
             <SWMansionIcon
               name="cross"
               size={24}
               color={styles.closeIcon.color}
             />
           </TouchableOpacity>
         </View>
         <View style={styles.parentNameWrapper}>
           <ThreadPill fontSize={12} threadInfo={parentThreadInfo} />
         </View>
       </View>
       <View style={styles.body}>
         <Search
           searchText={searchState.text}
           onChangeText={onChangeSearchInputText}
           containerStyle={styles.search}
           placeholder={searchPlaceholder ?? 'Search'}
           ref={setSearchTextInputRef}
         />
         <FlatList
           data={listData}
           renderItem={renderItem}
           keyExtractor={keyExtractor}
           getItemLayout={getItemLayout}
           keyboardShouldPersistTaps="handled"
           initialNumToRender={20}
           indicatorStyle={indicatorStyle}
         />
       </View>
     </Modal>
   );
 }
 
 const unboundStyles = {
   parentNameWrapper: {
     alignItems: 'flex-start',
   },
   body: {
     paddingHorizontal: 16,
     flex: 1,
   },
   headerTopRow: {
     flexDirection: 'row',
     justifyContent: 'space-between',
     height: 32,
     alignItems: 'center',
   },
   header: {
     borderBottomColor: 'subthreadsModalSearch',
     borderBottomWidth: 1,
     height: 94,
     padding: 16,
     justifyContent: 'space-between',
   },
   modal: {
     borderRadius: 8,
     paddingHorizontal: 0,
     backgroundColor: 'subthreadsModalBackground',
     paddingTop: 0,
     justifyContent: 'flex-start',
   },
   search: {
     height: 40,
     marginVertical: 16,
     backgroundColor: 'subthreadsModalSearch',
   },
   title: {
     color: 'listForegroundLabel',
     fontSize: 20,
     fontWeight: '500',
     lineHeight: 26,
     alignSelf: 'center',
     marginLeft: 2,
   },
   closeIcon: {
     color: 'subthreadsModalClose',
   },
   closeButton: {
     marginRight: 2,
     height: 40,
     alignItems: 'center',
     justifyContent: 'center',
   },
 };
 
 export default ThreadListModal;
diff --git a/native/media/file-utils.js b/native/media/file-utils.js
index c68298185..b7165e20e 100644
--- a/native/media/file-utils.js
+++ b/native/media/file-utils.js
@@ -1,447 +1,446 @@
 // @flow
 
 import base64 from 'base-64';
 import * as ExpoFileSystem from 'expo-file-system';
 import * as MediaLibrary from 'expo-media-library';
 import invariant from 'invariant';
 import { Platform } from 'react-native';
 import filesystem from 'react-native-fs';
 
 import {
   mediaConfig,
   pathFromURI,
   fileInfoFromData,
   bytesNeededForFileTypeCheck,
 } from 'lib/media/file-utils.js';
 import type {
   MediaMissionStep,
   MediaMissionFailure,
   MediaType,
   ReadFileHeaderMediaMissionStep,
   DisposeTemporaryFileMediaMissionStep,
   MakeDirectoryMediaMissionStep,
   AndroidScanFileMediaMissionStep,
   FetchFileHashMediaMissionStep,
   CopyFileMediaMissionStep,
 } from 'lib/types/media-types.js';
 import { getMessageForException } from 'lib/utils/errors.js';
 
 import { stringToIntArray } from './blob-utils.js';
 import { ffmpeg } from './ffmpeg.js';
 
 const defaultInputs = Object.freeze({});
 const defaultFields = Object.freeze({});
 
 export type FetchFileInfoResult = {
   +success: true,
   +uri: string,
   +orientation: ?number,
   +fileSize: number,
   +mime: ?string,
   +mediaType: ?MediaType,
 };
 type OptionalInputs = Partial<{ +mediaNativeID: ?string }>;
 type OptionalFields = Partial<{
   +orientation: boolean,
   +mediaType: boolean,
   +mime: boolean,
 }>;
 async function fetchFileInfo(
   inputURI: string,
   optionalInputs?: OptionalInputs = defaultInputs,
   optionalFields?: OptionalFields = defaultFields,
 ): Promise<{
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: MediaMissionFailure | FetchFileInfoResult,
 }> {
   const { mediaNativeID } = optionalInputs;
   const steps: Array<MediaMissionStep> = [];
 
   let assetInfoPromise, assetURI;
   const inputPath = pathFromURI(inputURI);
   if (mediaNativeID && (!inputPath || optionalFields.orientation)) {
     assetInfoPromise = (async () => {
       const { steps: assetInfoSteps, result: assetInfoResult } =
         await fetchAssetInfo(mediaNativeID);
       steps.push(...assetInfoSteps);
       assetURI = assetInfoResult.localURI;
       return assetInfoResult;
     })();
   }
 
   const getLocalURIPromise: Promise<?{
     +localURI: string,
     +path: string,
   }> = (async () => {
     if (inputPath) {
       return { localURI: inputURI, path: inputPath };
     }
     if (!assetInfoPromise) {
       return null;
     }
     const { localURI } = await assetInfoPromise;
     if (!localURI) {
       return null;
     }
     const path = pathFromURI(localURI);
     if (!path) {
       return null;
     }
     return { localURI, path };
   })();
 
   const getOrientationPromise: Promise<?number> = (async () => {
     if (!optionalFields.orientation || !assetInfoPromise) {
       return null;
     }
     const { orientation } = await assetInfoPromise;
     return orientation;
   })();
 
   const getFileSizePromise: Promise<?number> = (async () => {
     const localURIResult = await getLocalURIPromise;
     if (!localURIResult) {
       return null;
     }
     const { localURI } = localURIResult;
-    const { steps: fileSizeSteps, result: fileSize } = await fetchFileSize(
-      localURI,
-    );
+    const { steps: fileSizeSteps, result: fileSize } =
+      await fetchFileSize(localURI);
     steps.push(...fileSizeSteps);
     return fileSize;
   })();
 
   const getTypesPromise: Promise<{
     +mime: ?string,
     +mediaType: ?MediaType,
   }> = (async () => {
     if (!optionalFields.mime && !optionalFields.mediaType) {
       return { mime: null, mediaType: null };
     }
     const [localURIResult, fileSize] = await Promise.all([
       getLocalURIPromise,
       getFileSizePromise,
     ]);
     if (!localURIResult || !fileSize) {
       return { mime: null, mediaType: null };
     }
     const { localURI, path } = localURIResult;
     const readFileStep = await readFileHeader(localURI, fileSize);
     steps.push(readFileStep);
     const { mime, mediaType: baseMediaType } = readFileStep;
     if (!optionalFields.mediaType || !mime || !baseMediaType) {
       return { mime, mediaType: null };
     }
     const { steps: getMediaTypeSteps, result: mediaType } =
       await getMediaTypeInfo(path, mime, baseMediaType);
     steps.push(...getMediaTypeSteps);
     return { mime, mediaType };
   })();
 
   const [localURIResult, orientation, fileSize, types] = await Promise.all([
     getLocalURIPromise,
     getOrientationPromise,
     getFileSizePromise,
     getTypesPromise,
   ]);
   if (!localURIResult) {
     return { steps, result: { success: false, reason: 'no_file_path' } };
   }
   const uri = localURIResult.localURI;
   if (!fileSize) {
     return {
       steps,
       result: { success: false, reason: 'file_stat_failed', uri },
     };
   }
 
   let finalURI = uri;
   // prefer asset URI, with one exception:
   // if the target URI is a file in our app local cache dir, we shouldn't
   // replace it because it was already preprocessed by either our media
   // processing logic or cropped by expo-image-picker
   const isFileInCacheDir =
     uri.includes(temporaryDirectoryPath) ||
     uri.includes(ExpoFileSystem.cacheDirectory);
   if (assetURI && assetURI !== uri && !isFileInCacheDir) {
     finalURI = assetURI;
     console.log(
       'fetchAssetInfo returned localURI ' +
         `${assetURI} when we already had ${uri}`,
     );
   }
 
   return {
     steps,
     result: {
       success: true,
       uri: finalURI,
       orientation,
       fileSize,
       mime: types.mime,
       mediaType: types.mediaType,
     },
   };
 }
 
 async function fetchAssetInfo(mediaNativeID: string): Promise<{
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: { localURI: ?string, orientation: ?number },
 }> {
   let localURI,
     orientation,
     success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     const assetInfo = await MediaLibrary.getAssetInfoAsync(mediaNativeID);
     success = true;
     localURI = assetInfo.localUri;
     if (Platform.OS === 'ios') {
       orientation = assetInfo.orientation;
     } else {
       orientation = assetInfo.exif && assetInfo.exif.Orientation;
     }
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     steps: [
       {
         step: 'asset_info_fetch',
         success,
         exceptionMessage,
         time: Date.now() - start,
         localURI,
         orientation,
       },
     ],
     result: {
       localURI,
       orientation,
     },
   };
 }
 
 async function fetchFileSize(uri: string): Promise<{
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: ?number,
 }> {
   let fileSize,
     success = false,
     exceptionMessage;
   const statStart = Date.now();
   try {
     const result = await filesystem.stat(uri);
     success = true;
     fileSize = result.size;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     steps: [
       {
         step: 'stat_file',
         success,
         exceptionMessage,
         time: Date.now() - statStart,
         uri,
         fileSize,
       },
     ],
     result: fileSize,
   };
 }
 
 async function readFileHeader(
   localURI: string,
   fileSize: number,
 ): Promise<ReadFileHeaderMediaMissionStep> {
   const fetchBytes = Math.min(fileSize, bytesNeededForFileTypeCheck);
 
   const start = Date.now();
   let fileData,
     success = false,
     exceptionMessage;
   try {
     fileData = await filesystem.read(localURI, fetchBytes, 0, 'base64');
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
 
   let mime, mediaType;
   if (fileData) {
     const utf8 = base64.decode(fileData);
     const intArray = stringToIntArray(utf8);
     ({ mime, mediaType } = fileInfoFromData(intArray));
   }
 
   return {
     step: 'read_file_header',
     success,
     exceptionMessage,
     time: Date.now() - start,
     uri: localURI,
     mime,
     mediaType,
   };
 }
 
 async function getMediaTypeInfo(
   path: string,
   mime: string,
   baseMediaType: MediaType,
 ): Promise<{
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: ?MediaType,
 }> {
   if (!mediaConfig[mime] || mediaConfig[mime].mediaType !== 'photo_or_video') {
     return { steps: [], result: baseMediaType };
   }
 
   let hasMultipleFrames,
     success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     hasMultipleFrames = await ffmpeg.hasMultipleFrames(path);
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   const steps = [
     {
       step: 'frame_count',
       success,
       exceptionMessage,
       time: Date.now() - start,
       path,
       mime,
       hasMultipleFrames,
     },
   ];
   const result = hasMultipleFrames ? 'video' : 'photo';
   return { steps, result };
 }
 
 async function disposeTempFile(
   path: string,
 ): Promise<DisposeTemporaryFileMediaMissionStep> {
   let success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     await filesystem.unlink(path);
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     step: 'dispose_temporary_file',
     success,
     exceptionMessage,
     time: Date.now() - start,
     path,
   };
 }
 
 async function mkdir(path: string): Promise<MakeDirectoryMediaMissionStep> {
   let success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     await filesystem.mkdir(path);
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     step: 'make_directory',
     success,
     exceptionMessage,
     time: Date.now() - start,
     path,
   };
 }
 
 async function androidScanFile(
   path: string,
 ): Promise<AndroidScanFileMediaMissionStep> {
   invariant(Platform.OS === 'android', 'androidScanFile only works on Android');
   let success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     await filesystem.scanFile(path);
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     step: 'android_scan_file',
     success,
     exceptionMessage,
     time: Date.now() - start,
     path,
   };
 }
 
 async function fetchFileHash(
   path: string,
 ): Promise<FetchFileHashMediaMissionStep> {
   let hash, exceptionMessage;
   const start = Date.now();
   try {
     hash = await filesystem.hash(path, 'md5');
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     step: 'fetch_file_hash',
     success: !!hash,
     exceptionMessage,
     time: Date.now() - start,
     path,
     hash,
   };
 }
 
 async function copyFile(
   source: string,
   destination: string,
 ): Promise<CopyFileMediaMissionStep> {
   let success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     await filesystem.copyFile(source, destination);
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     step: 'copy_file',
     success,
     exceptionMessage,
     time: Date.now() - start,
     source,
     destination,
   };
 }
 
 const temporaryDirectoryPath: string = Platform.select({
   ios: filesystem.TemporaryDirectoryPath,
   default: `${filesystem.TemporaryDirectoryPath}/`,
 });
 
 export {
   fetchAssetInfo,
   fetchFileInfo,
   temporaryDirectoryPath,
   disposeTempFile,
   mkdir,
   androidScanFile,
   fetchFileHash,
   copyFile,
 };
diff --git a/native/media/save-media.js b/native/media/save-media.js
index 0878efca4..64e39b11b 100644
--- a/native/media/save-media.js
+++ b/native/media/save-media.js
@@ -1,477 +1,476 @@
 // @flow
 
 import * as MediaLibrary from 'expo-media-library';
 import invariant from 'invariant';
 import * as React from 'react';
 import { Platform, PermissionsAndroid } from 'react-native';
 import filesystem from 'react-native-fs';
 
 import { queueReportsActionType } from 'lib/actions/report-actions.js';
 import { readableFilename, pathFromURI } from 'lib/media/file-utils.js';
 import { isLocalUploadID } from 'lib/media/media-utils.js';
 import type {
   MediaMissionStep,
   MediaMissionResult,
   MediaMissionFailure,
 } from 'lib/types/media-types.js';
 import {
   reportTypes,
   type ClientMediaMissionReportCreationRequest,
 } from 'lib/types/report-types.js';
 import { getConfig } from 'lib/utils/config.js';
 import { getMessageForException } from 'lib/utils/errors.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import {
   generateReportID,
   useIsReportEnabled,
 } from 'lib/utils/report-utils.js';
 
 import { fetchBlob } from './blob-utils.js';
 import {
   fetchAssetInfo,
   fetchFileInfo,
   disposeTempFile,
   mkdir,
   androidScanFile,
   fetchFileHash,
   copyFile,
   temporaryDirectoryPath,
   type FetchFileInfoResult,
 } from './file-utils.js';
 import { getMediaLibraryIdentifier } from './identifier-utils.js';
 import { displayActionResultModal } from '../navigation/action-result-modal.js';
 import { requestAndroidPermission } from '../utils/android-permissions.js';
 
 export type IntentionalSaveMedia = (
   uri: string,
   ids: {
     uploadID: string,
     messageServerID: ?string,
     messageLocalID: ?string,
   },
 ) => Promise<void>;
 
 function useIntentionalSaveMedia(): IntentionalSaveMedia {
   const dispatch = useDispatch();
   const mediaReportsEnabled = useIsReportEnabled('mediaReports');
   return React.useCallback(
     async (
       uri: string,
       ids: {
         uploadID: string,
         messageServerID: ?string,
         messageLocalID: ?string,
       },
     ) => {
       const start = Date.now();
       const steps: Array<MediaMissionStep> = [
         { step: 'save_media', uri, time: start },
       ];
 
       const { resultPromise, reportPromise } = saveMedia(uri, 'request');
       const result = await resultPromise;
       const userTime = Date.now() - start;
 
       let message;
       if (result.success) {
         message = 'saved!';
       } else if (result.reason === 'save_unsupported') {
         const os: string = Platform.select({
           ios: 'iOS',
           android: 'Android',
           default: Platform.OS,
         });
         message = `saving media is unsupported on ${os}`;
       } else if (result.reason === 'missing_permission') {
         message = 'don’t have permission :(';
       } else if (
         result.reason === 'resolve_failed' ||
         result.reason === 'data_uri_failed'
       ) {
         message = 'failed to resolve :(';
       } else if (result.reason === 'fetch_failed') {
         message = 'failed to download :(';
       } else {
         message = 'failed to save :(';
       }
       displayActionResultModal(message);
 
       if (!mediaReportsEnabled) {
         return;
       }
       const reportSteps = await reportPromise;
       steps.push(...reportSteps);
       const totalTime = Date.now() - start;
       const mediaMission = { steps, result, userTime, totalTime };
 
       const { uploadID, messageServerID, messageLocalID } = ids;
       const uploadIDIsLocal = isLocalUploadID(uploadID);
       const report: ClientMediaMissionReportCreationRequest = {
         type: reportTypes.MEDIA_MISSION,
         time: Date.now(),
         platformDetails: getConfig().platformDetails,
         mediaMission,
         uploadServerID: uploadIDIsLocal ? undefined : uploadID,
         uploadLocalID: uploadIDIsLocal ? uploadID : undefined,
         messageServerID,
         messageLocalID,
         id: generateReportID(),
       };
       dispatch({
         type: queueReportsActionType,
         payload: { reports: [report] },
       });
     },
     [dispatch, mediaReportsEnabled],
   );
 }
 
 type Permissions = 'check' | 'request';
 
 function saveMedia(
   uri: string,
   permissions?: Permissions = 'check',
 ): {
   resultPromise: Promise<MediaMissionResult>,
   reportPromise: Promise<$ReadOnlyArray<MediaMissionStep>>,
 } {
   let resolveResult;
   const sendResult = (result: MediaMissionResult) => {
     if (resolveResult) {
       resolveResult(result);
     }
   };
 
   const reportPromise = innerSaveMedia(uri, permissions, sendResult);
   const resultPromise = new Promise<MediaMissionResult>(resolve => {
     resolveResult = resolve;
   });
 
   return { reportPromise, resultPromise };
 }
 
 async function innerSaveMedia(
   uri: string,
   permissions: Permissions,
   sendResult: (result: MediaMissionResult) => void,
 ): Promise<$ReadOnlyArray<MediaMissionStep>> {
   if (Platform.OS === 'android') {
     return await saveMediaAndroid(uri, permissions, sendResult);
   } else if (Platform.OS === 'ios') {
     return await saveMediaIOS(uri, sendResult);
   } else {
     sendResult({ success: false, reason: 'save_unsupported' });
     return [];
   }
 }
 
 const androidSavePermission =
   PermissionsAndroid.PERMISSIONS.WRITE_EXTERNAL_STORAGE;
 
 // On Android, we save the media to our own Comm folder in the
 // Pictures directory, and then trigger the media scanner to pick it up
 async function saveMediaAndroid(
   inputURI: string,
   permissions: Permissions,
   sendResult: (result: MediaMissionResult) => void,
 ): Promise<$ReadOnlyArray<MediaMissionStep>> {
   const steps: Array<MediaMissionStep> = [];
 
   let hasPermission = false,
     permissionCheckExceptionMessage;
   const permissionCheckStart = Date.now();
   try {
     hasPermission = await requestAndroidPermission(
       androidSavePermission,
       'throw',
     );
   } catch (e) {
     permissionCheckExceptionMessage = getMessageForException(e);
   }
   steps.push({
     step: 'permissions_check',
     success: hasPermission,
     exceptionMessage: permissionCheckExceptionMessage,
     time: Date.now() - permissionCheckStart,
     platform: Platform.OS,
     permissions: [androidSavePermission],
   });
   if (!hasPermission) {
     sendResult({ success: false, reason: 'missing_permission' });
     return steps;
   }
 
   const promises = [];
   let success = true;
   const saveFolder = `${filesystem.PicturesDirectoryPath}/Comm/`;
   promises.push(
     (async () => {
       const makeDirectoryStep = await mkdir(saveFolder);
       if (!makeDirectoryStep.success) {
         success = false;
         sendResult({ success, reason: 'make_directory_failed' });
       }
       steps.push(makeDirectoryStep);
     })(),
   );
 
   let uri = inputURI;
   let tempFile, mime;
   if (uri.startsWith('http')) {
     promises.push(
       (async () => {
         const { result: tempSaveResult, steps: tempSaveSteps } =
           await saveRemoteMediaToDisk(uri, temporaryDirectoryPath);
         steps.push(...tempSaveSteps);
         if (!tempSaveResult.success) {
           success = false;
           sendResult(tempSaveResult);
         } else {
           tempFile = tempSaveResult.path;
           uri = `file://${tempFile}`;
           mime = tempSaveResult.mime;
         }
       })(),
     );
   }
 
   await Promise.all(promises);
   if (!success) {
     return steps;
   }
 
   const { result: copyResult, steps: copySteps } = await copyToSortedDirectory(
     uri,
     saveFolder,
     mime,
   );
   steps.push(...copySteps);
   if (!copyResult.success) {
     sendResult(copyResult);
     return steps;
   }
   sendResult({ success: true });
 
   const postResultPromises = [];
 
   postResultPromises.push(
     (async () => {
       const scanFileStep = await androidScanFile(copyResult.path);
       steps.push(scanFileStep);
     })(),
   );
 
   if (tempFile) {
     postResultPromises.push(
       (async (file: string) => {
         const disposeStep = await disposeTempFile(file);
         steps.push(disposeStep);
       })(tempFile),
     );
   }
 
   await Promise.all(postResultPromises);
   return steps;
 }
 
 // On iOS, we save the media to the camera roll
 async function saveMediaIOS(
   inputURI: string,
   sendResult: (result: MediaMissionResult) => void,
 ): Promise<$ReadOnlyArray<MediaMissionStep>> {
   const steps: Array<MediaMissionStep> = [];
 
   let uri = inputURI;
   let tempFile;
   if (uri.startsWith('http')) {
     const { result: tempSaveResult, steps: tempSaveSteps } =
       await saveRemoteMediaToDisk(uri, temporaryDirectoryPath);
     steps.push(...tempSaveSteps);
     if (!tempSaveResult.success) {
       sendResult(tempSaveResult);
       return steps;
     }
     tempFile = tempSaveResult.path;
     uri = `file://${tempFile}`;
   } else if (!uri.startsWith('file://')) {
     const mediaNativeID = getMediaLibraryIdentifier(uri);
     if (mediaNativeID) {
       const { result: fetchAssetInfoResult, steps: fetchAssetInfoSteps } =
         await fetchAssetInfo(mediaNativeID);
       steps.push(...fetchAssetInfoSteps);
       const { localURI } = fetchAssetInfoResult;
       if (localURI) {
         uri = localURI;
       }
     }
   }
 
   if (!uri.startsWith('file://')) {
     sendResult({ success: false, reason: 'resolve_failed', uri });
     return steps;
   }
 
   let success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     await MediaLibrary.saveToLibraryAsync(uri);
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   steps.push({
     step: 'ios_save_to_library',
     success,
     exceptionMessage,
     time: Date.now() - start,
     uri,
   });
 
   if (success) {
     sendResult({ success: true });
   } else {
     sendResult({ success: false, reason: 'save_to_library_failed', uri });
   }
 
   if (tempFile) {
     const disposeStep = await disposeTempFile(tempFile);
     steps.push(disposeStep);
   }
   return steps;
 }
 
 type IntermediateSaveResult = {
   result: { success: true, path: string, mime: string } | MediaMissionFailure,
   steps: $ReadOnlyArray<MediaMissionStep>,
 };
 
 async function saveRemoteMediaToDisk(
   inputURI: string,
   directory: string, // should end with a /
 ): Promise<IntermediateSaveResult> {
   const steps: Array<MediaMissionStep> = [];
 
-  const { result: fetchBlobResult, steps: fetchBlobSteps } = await fetchBlob(
-    inputURI,
-  );
+  const { result: fetchBlobResult, steps: fetchBlobSteps } =
+    await fetchBlob(inputURI);
   steps.push(...fetchBlobSteps);
   if (!fetchBlobResult.success) {
     return { result: fetchBlobResult, steps };
   }
   const { mime, base64 } = fetchBlobResult;
 
   const tempName = readableFilename('', mime);
   if (!tempName) {
     return {
       result: { success: false, reason: 'mime_check_failed', mime },
       steps,
     };
   }
   const tempPath = `${directory}tempsave.${tempName}`;
 
   const start = Date.now();
   let success = false,
     exceptionMessage;
   try {
     await filesystem.writeFile(tempPath, base64, 'base64');
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   steps.push({
     step: 'write_file',
     success,
     exceptionMessage,
     time: Date.now() - start,
     path: tempPath,
     length: base64.length,
   });
 
   if (!success) {
     return { result: { success: false, reason: 'write_file_failed' }, steps };
   }
   return { result: { success: true, path: tempPath, mime }, steps };
 }
 
 async function copyToSortedDirectory(
   localURI: string,
   directory: string, // should end with a /
   inputMIME: ?string,
 ): Promise<IntermediateSaveResult> {
   const steps: Array<MediaMissionStep> = [];
 
   const path = pathFromURI(localURI);
   if (!path) {
     return {
       result: { success: false, reason: 'resolve_failed', uri: localURI },
       steps,
     };
   }
   let mime = inputMIME;
 
   const hashStepPromise = fetchFileHash(path);
   const fileInfoPromise: Promise<?{
     steps: $ReadOnlyArray<MediaMissionStep>,
     result: MediaMissionFailure | FetchFileInfoResult,
   }> = (async () => {
     if (mime) {
       return undefined;
     }
     return await fetchFileInfo(localURI, undefined, {
       mime: true,
     });
   })();
   const [hashStep, fileInfoResult] = await Promise.all([
     hashStepPromise,
     fileInfoPromise,
   ]);
 
   steps.push(hashStep);
   if (!hashStep.success) {
     return {
       result: { success: false, reason: 'fetch_file_hash_failed' },
       steps,
     };
   }
   const { hash } = hashStep;
   invariant(hash, 'hash should be truthy if hashStep.success is truthy');
 
   if (fileInfoResult) {
     steps.push(...fileInfoResult.steps);
     if (fileInfoResult.result.success && fileInfoResult.result.mime) {
       ({ mime } = fileInfoResult.result);
     }
   }
   if (!mime) {
     return {
       result: { success: false, reason: 'mime_check_failed', mime },
       steps,
     };
   }
 
   const name = readableFilename(hash, mime);
   if (!name) {
     return {
       result: { success: false, reason: 'mime_check_failed', mime },
       steps,
     };
   }
   const newPath = `${directory}${name}`;
 
   const copyStep = await copyFile(path, newPath);
   steps.push(copyStep);
   if (!copyStep.success) {
     return {
       result: { success: false, reason: 'copy_file_failed' },
       steps,
     };
   }
 
   return {
     result: { success: true, path: newPath, mime },
     steps,
   };
 }
 
 export { useIntentionalSaveMedia, saveMedia };
diff --git a/native/navigation/nav-selectors.js b/native/navigation/nav-selectors.js
index fa9f77131..022ee2811 100644
--- a/native/navigation/nav-selectors.js
+++ b/native/navigation/nav-selectors.js
@@ -1,445 +1,445 @@
 // @flow
 
 import type { PossiblyStaleNavigationState } from '@react-navigation/core';
 import { useRoute } from '@react-navigation/native';
 import _memoize from 'lodash/memoize.js';
 import * as React from 'react';
 import { createSelector } from 'reselect';
 
 import { nonThreadCalendarFiltersSelector } from 'lib/selectors/calendar-filter-selectors.js';
 import { currentCalendarQuery } from 'lib/selectors/nav-selectors.js';
 import { useCanEditMessage } from 'lib/shared/edit-messages-utils.js';
 import type { CalendarQuery } from 'lib/types/entry-types.js';
 import type { CalendarFilter } from 'lib/types/filter-types.js';
 import type {
   ComposableMessageInfo,
   RobotextMessageInfo,
 } from 'lib/types/message-types.js';
 import type { GlobalTheme } from 'lib/types/theme-types.js';
 import type { ThreadInfo } from 'lib/types/thread-types.js';
 
 import type { NavContextType } from './navigation-context.js';
 import { NavContext } from './navigation-context.js';
 import {
   getStateFromNavigatorRoute,
   getThreadIDFromRoute,
   currentLeafRoute,
 } from './navigation-utils.js';
 import {
   AppRouteName,
   TabNavigatorRouteName,
   MessageListRouteName,
   ChatRouteName,
   CalendarRouteName,
   ThreadPickerModalRouteName,
   ActionResultModalRouteName,
   accountModals,
   scrollBlockingModals,
   chatRootModals,
   threadRoutes,
   CommunityDrawerNavigatorRouteName,
   MessageResultsScreenRouteName,
   MessageSearchRouteName,
 } from './route-names.js';
 import type { RemoveEditMode } from '../chat/message-list-types.js';
 import { useSelector } from '../redux/redux-utils.js';
 import type { NavPlusRedux } from '../types/selector-types.js';
 
 const baseCreateIsForegroundSelector: (
   routeName: string,
 ) => (context: ?NavContextType) => boolean = (routeName: string) =>
   createSelector(
     (context: ?NavContextType) => context && context.state,
     (navigationState: ?PossiblyStaleNavigationState) => {
       if (!navigationState) {
         return false;
       }
       return navigationState.routes[navigationState.index].name === routeName;
     },
   );
 const createIsForegroundSelector: (
   routeName: string,
 ) => (context: ?NavContextType) => boolean = _memoize(
   baseCreateIsForegroundSelector,
 );
 
 function useIsAppLoggedIn(): boolean {
   const navContext = React.useContext(NavContext);
   return React.useMemo(() => {
     if (!navContext) {
       return false;
     }
     const { state } = navContext;
     return !accountModals.includes(state.routes[state.index].name);
   }, [navContext]);
 }
 
 const baseCreateActiveTabSelector: (
   routeName: string,
 ) => (context: ?NavContextType) => boolean = (routeName: string) =>
   createSelector(
     (context: ?NavContextType) => context && context.state,
     (navigationState: ?PossiblyStaleNavigationState) => {
       if (!navigationState) {
         return false;
       }
       const currentRootSubroute = navigationState.routes[navigationState.index];
       if (currentRootSubroute.name !== AppRouteName) {
         return false;
       }
       const appState = getStateFromNavigatorRoute(currentRootSubroute);
       const [firstAppSubroute] = appState.routes;
       if (firstAppSubroute.name !== CommunityDrawerNavigatorRouteName) {
         return false;
       }
       const communityDrawerState = getStateFromNavigatorRoute(firstAppSubroute);
       const [firstCommunityDrawerSubroute] = communityDrawerState.routes;
       if (firstCommunityDrawerSubroute.name !== TabNavigatorRouteName) {
         return false;
       }
       const tabState = getStateFromNavigatorRoute(firstCommunityDrawerSubroute);
       return tabState.routes[tabState.index].name === routeName;
     },
   );
 const createActiveTabSelector: (
   routeName: string,
 ) => (context: ?NavContextType) => boolean = _memoize(
   baseCreateActiveTabSelector,
 );
 
 const scrollBlockingModalsClosedSelector: (
   context: ?NavContextType,
 ) => boolean = createSelector(
   (context: ?NavContextType) => context && context.state,
   (navigationState: ?PossiblyStaleNavigationState) => {
     if (!navigationState) {
       return false;
     }
     const currentRootSubroute = navigationState.routes[navigationState.index];
     if (currentRootSubroute.name !== AppRouteName) {
       return true;
     }
     const appState = getStateFromNavigatorRoute(currentRootSubroute);
     for (let i = appState.index; i >= 0; i--) {
       const route = appState.routes[i];
       if (scrollBlockingModals.includes(route.name)) {
         return false;
       }
     }
     return true;
   },
 );
 
 function selectBackgroundIsDark(
   navigationState: ?PossiblyStaleNavigationState,
   theme: ?GlobalTheme,
 ): boolean {
   if (!navigationState) {
     return false;
   }
   const currentRootSubroute = navigationState.routes[navigationState.index];
   if (currentRootSubroute.name !== AppRouteName) {
     // Very bright... we'll call it non-dark. Doesn't matter right now since
     // we only use this selector for determining ActionResultModal appearance
     return false;
   }
   const appState = getStateFromNavigatorRoute(currentRootSubroute);
   let appIndex = appState.index;
   let currentAppSubroute = appState.routes[appIndex];
   while (currentAppSubroute.name === ActionResultModalRouteName) {
     currentAppSubroute = appState.routes[--appIndex];
   }
   if (scrollBlockingModals.includes(currentAppSubroute.name)) {
     // All the scroll-blocking chat modals have a dark background
     return true;
   }
   return theme === 'dark';
 }
 
 function activeThread(
   navigationState: ?PossiblyStaleNavigationState,
   validRouteNames: $ReadOnlyArray<string>,
 ): ?string {
   if (!navigationState) {
     return null;
   }
   let rootIndex = navigationState.index;
   let currentRootSubroute = navigationState.routes[rootIndex];
   while (currentRootSubroute.name !== AppRouteName) {
     if (!chatRootModals.includes(currentRootSubroute.name)) {
       return null;
     }
     if (rootIndex === 0) {
       return null;
     }
     currentRootSubroute = navigationState.routes[--rootIndex];
   }
   const appState = getStateFromNavigatorRoute(currentRootSubroute);
   const [firstAppSubroute] = appState.routes;
   if (firstAppSubroute.name !== CommunityDrawerNavigatorRouteName) {
     return null;
   }
   const communityDrawerState = getStateFromNavigatorRoute(firstAppSubroute);
   const [firstCommunityDrawerSubroute] = communityDrawerState.routes;
   if (firstCommunityDrawerSubroute.name !== TabNavigatorRouteName) {
     return null;
   }
   const tabState = getStateFromNavigatorRoute(firstCommunityDrawerSubroute);
   const currentTabSubroute = tabState.routes[tabState.index];
   if (currentTabSubroute.name !== ChatRouteName) {
     return null;
   }
   const chatState = getStateFromNavigatorRoute(currentTabSubroute);
   const currentChatSubroute = chatState.routes[chatState.index];
   return getThreadIDFromRoute(currentChatSubroute, validRouteNames);
 }
 
 const activeThreadSelector: (context: ?NavContextType) => ?string =
   createSelector(
     (context: ?NavContextType) => context && context.state,
     (navigationState: ?PossiblyStaleNavigationState): ?string =>
       activeThread(navigationState, threadRoutes),
   );
 
 const messageListRouteNames = [MessageListRouteName];
 const activeMessageListSelector: (context: ?NavContextType) => ?string =
   createSelector(
     (context: ?NavContextType) => context && context.state,
     (navigationState: ?PossiblyStaleNavigationState): ?string =>
       activeThread(navigationState, messageListRouteNames),
   );
 
 function useActiveThread(): ?string {
   const navContext = React.useContext(NavContext);
   return React.useMemo(() => {
     if (!navContext) {
       return null;
     }
     const { state } = navContext;
     return activeThread(state, threadRoutes);
   }, [navContext]);
 }
 
 function useActiveMessageList(): ?string {
   const navContext = React.useContext(NavContext);
   return React.useMemo(() => {
     if (!navContext) {
       return null;
     }
     const { state } = navContext;
     return activeThread(state, messageListRouteNames);
   }, [navContext]);
 }
 
 const calendarTabActiveSelector = createActiveTabSelector(CalendarRouteName);
 const threadPickerActiveSelector = createIsForegroundSelector(
   ThreadPickerModalRouteName,
 );
 const calendarActiveSelector: (context: ?NavContextType) => boolean =
   createSelector(
     calendarTabActiveSelector,
     threadPickerActiveSelector,
     (calendarTabActive: boolean, threadPickerActive: boolean) =>
       calendarTabActive || threadPickerActive,
   );
 
 const nativeCalendarQuery: (input: NavPlusRedux) => () => CalendarQuery =
   createSelector(
     (input: NavPlusRedux) => currentCalendarQuery(input.redux),
     (input: NavPlusRedux) => calendarActiveSelector(input.navContext),
     (
-        calendarQuery: (calendarActive: boolean) => CalendarQuery,
-        calendarActive: boolean,
-      ) =>
+      calendarQuery: (calendarActive: boolean) => CalendarQuery,
+      calendarActive: boolean,
+    ) =>
       () =>
         calendarQuery(calendarActive),
   );
 
 const nonThreadCalendarQuery: (input: NavPlusRedux) => () => CalendarQuery =
   createSelector(
     nativeCalendarQuery,
     (input: NavPlusRedux) => nonThreadCalendarFiltersSelector(input.redux),
     (
       calendarQuery: () => CalendarQuery,
       filters: $ReadOnlyArray<CalendarFilter>,
     ) => {
       return (): CalendarQuery => {
         const query = calendarQuery();
         return {
           startDate: query.startDate,
           endDate: query.endDate,
           filters,
         };
       };
     },
   );
 
 function useCalendarQuery(): () => CalendarQuery {
   const navContext = React.useContext(NavContext);
   return useSelector(state =>
     nonThreadCalendarQuery({
       redux: state,
       navContext,
     }),
   );
 }
 
 const drawerSwipeEnabledSelector: (context: ?NavContextType) => boolean =
   createSelector(
     (context: ?NavContextType) => context && context.state,
     (navigationState: ?PossiblyStaleNavigationState) => {
       if (!navigationState) {
         return true;
       }
 
       // First, we recurse into the navigation state until we find the tab route
       // The tab route should always be accessible by recursing through the
       // first routes of each subsequent nested navigation state
       const [firstRootSubroute] = navigationState.routes;
       if (firstRootSubroute.name !== AppRouteName) {
         return true;
       }
       const appState = getStateFromNavigatorRoute(firstRootSubroute);
       const [firstAppSubroute] = appState.routes;
       if (firstAppSubroute.name !== CommunityDrawerNavigatorRouteName) {
         return true;
       }
       const communityDrawerState = getStateFromNavigatorRoute(firstAppSubroute);
       const [firstCommunityDrawerSubroute] = communityDrawerState.routes;
       if (firstCommunityDrawerSubroute.name !== TabNavigatorRouteName) {
         return true;
       }
       const tabState = getStateFromNavigatorRoute(firstCommunityDrawerSubroute);
 
       // Once we have the tab state, we want to figure out if we currently have
       // an active StackNavigator
       const currentTabSubroute = tabState.routes[tabState.index];
       if (!currentTabSubroute.state) {
         return true;
       }
       const currentTabSubrouteState =
         getStateFromNavigatorRoute(currentTabSubroute);
       if (currentTabSubrouteState.type !== 'stack') {
         return true;
       }
 
       // Finally, we want to disable the swipe gesture if there is a stack with
       // more than one subroute, since then the stack will have its own swipe
       // gesture that will conflict with the drawer's
       return currentTabSubrouteState.routes.length < 2;
     },
   );
 
 function getTabNavState(
   navigationState: ?PossiblyStaleNavigationState,
 ): ?PossiblyStaleNavigationState {
   if (!navigationState) {
     return null;
   }
   const [firstAppSubroute] = navigationState.routes;
   if (firstAppSubroute.name !== CommunityDrawerNavigatorRouteName) {
     return null;
   }
 
   const communityDrawerState = getStateFromNavigatorRoute(firstAppSubroute);
   const [firstCommunityDrawerSubroute] = communityDrawerState.routes;
   if (firstCommunityDrawerSubroute.name !== TabNavigatorRouteName) {
     return null;
   }
 
   const tabState = getStateFromNavigatorRoute(firstCommunityDrawerSubroute);
   return tabState;
 }
 
 function getChatNavStateFromTabNavState(
   tabState: ?PossiblyStaleNavigationState,
 ): ?PossiblyStaleNavigationState {
   if (!tabState) {
     return null;
   }
   let chatRoute;
   for (const route of tabState.routes) {
     if (route.name === ChatRouteName) {
       chatRoute = route;
       break;
     }
   }
   if (!chatRoute || !chatRoute.state) {
     return null;
   }
   const chatRouteState = getStateFromNavigatorRoute(chatRoute);
   if (chatRouteState.type !== 'stack') {
     return null;
   }
   return chatRouteState;
 }
 
 function getRemoveEditMode(
   chatRouteState: ?PossiblyStaleNavigationState,
 ): ?RemoveEditMode {
   if (!chatRouteState) {
     return null;
   }
   const messageListRoute =
     chatRouteState.routes[chatRouteState.routes.length - 1];
   if (messageListRoute.name !== MessageListRouteName) {
     return null;
   }
   if (!messageListRoute || !messageListRoute.params) {
     return null;
   }
   const removeEditMode: Function = messageListRoute.params.removeEditMode;
   return removeEditMode;
 }
 
 function useCurrentLeafRouteName(): ?string {
   const navContext = React.useContext(NavContext);
   return React.useMemo(() => {
     if (!navContext) {
       return undefined;
     }
     return currentLeafRoute(navContext.state).name;
   }, [navContext]);
 }
 
 function useCanEditMessageNative(
   threadInfo: ThreadInfo,
   targetMessageInfo: ComposableMessageInfo | RobotextMessageInfo,
 ): boolean {
   const route = useRoute();
 
   const screenKey = route.key;
   const threadCreationTime = threadInfo.creationTime;
   const messageCreationTime = targetMessageInfo.time;
 
   const canEditInThisScreen =
     !screenKey.startsWith(MessageSearchRouteName) &&
     !screenKey.startsWith(MessageResultsScreenRouteName) &&
     messageCreationTime >= threadCreationTime;
 
   return (
     useCanEditMessage(threadInfo, targetMessageInfo) && canEditInThisScreen
   );
 }
 
 export {
   createIsForegroundSelector,
   useIsAppLoggedIn,
   createActiveTabSelector,
   scrollBlockingModalsClosedSelector,
   selectBackgroundIsDark,
   activeThreadSelector,
   activeMessageListSelector,
   useActiveThread,
   useActiveMessageList,
   calendarActiveSelector,
   nativeCalendarQuery,
   nonThreadCalendarQuery,
   useCalendarQuery,
   drawerSwipeEnabledSelector,
   useCurrentLeafRouteName,
   getRemoveEditMode,
   getTabNavState,
   getChatNavStateFromTabNavState,
   useCanEditMessageNative,
 };
diff --git a/native/profile/relationship-list.react.js b/native/profile/relationship-list.react.js
index 0060b170d..d575176dc 100644
--- a/native/profile/relationship-list.react.js
+++ b/native/profile/relationship-list.react.js
@@ -1,490 +1,490 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View, Text, Platform } from 'react-native';
 import { FlatList } from 'react-native-gesture-handler';
 
 import {
   updateRelationshipsActionTypes,
   updateRelationships,
 } from 'lib/actions/relationship-actions.js';
 import { useENSNames } from 'lib/hooks/ens-cache.js';
 import { registerFetchKey } from 'lib/reducers/loading-reducer.js';
 import { useUserSearchIndex } from 'lib/selectors/nav-selectors.js';
 import { userRelationshipsSelector } from 'lib/selectors/relationship-selectors.js';
 import { useSearchUsers } from 'lib/shared/search-utils.js';
 import {
   userRelationshipStatus,
   relationshipActions,
 } from 'lib/types/relationship-types.js';
 import type {
   GlobalAccountUserInfo,
   AccountUserInfo,
 } from 'lib/types/user-types.js';
 import {
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils.js';
 import { values } from 'lib/utils/objects.js';
 
 import type { ProfileNavigationProp } from './profile.react.js';
 import RelationshipListItem from './relationship-list-item.react.js';
 import LinkButton from '../components/link-button.react.js';
 import { createTagInput, BaseTagInput } from '../components/tag-input.react.js';
 import { KeyboardContext } from '../keyboard/keyboard-state.js';
 import { OverlayContext } from '../navigation/overlay-context.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import {
   FriendListRouteName,
   BlockListRouteName,
 } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStyles, useIndicatorStyle } from '../themes/colors.js';
 import type { VerticalBounds } from '../types/layout-types.js';
 import Alert from '../utils/alert.js';
 
 const TagInput = createTagInput<GlobalAccountUserInfo>();
 
 export type RelationshipListNavigate = $PropertyType<
   ProfileNavigationProp<'FriendList' | 'BlockList'>,
   'navigate',
 >;
 
 const tagInputProps = {
   placeholder: 'username',
   autoFocus: true,
   returnKeyType: 'go',
 };
 
 type ListItem =
   | { +type: 'empty', +because: 'no-relationships' | 'no-results' }
   | { +type: 'header' }
   | { +type: 'footer' }
   | {
       +type: 'user',
       +userInfo: AccountUserInfo,
       +lastListItem: boolean,
       +verticalBounds: ?VerticalBounds,
     };
 
 // ESLint doesn't recognize that invariant always throws
 // eslint-disable-next-line consistent-return
 function keyExtractor(item: ListItem) {
   if (item.userInfo) {
     return item.userInfo.id;
   } else if (item.type === 'empty') {
     return 'empty';
   } else if (item.type === 'header') {
     return 'header';
   } else if (item.type === 'footer') {
     return 'footer';
   }
   invariant(false, 'keyExtractor conditions should be exhaustive');
 }
 
 const tagDataLabelExtractor = (userInfo: GlobalAccountUserInfo) =>
   userInfo.username;
 
 type Props = {
   +navigation: ProfileNavigationProp<'FriendList' | 'BlockList'>,
   +route: NavigationRoute<'FriendList' | 'BlockList'>,
 };
 function RelationshipList(props: Props): React.Node {
   const { route } = props;
   const routeName = route.name;
   const excludeStatuses = React.useMemo(
     () =>
       ({
         [FriendListRouteName]: [
           userRelationshipStatus.BLOCKED_VIEWER,
           userRelationshipStatus.BOTH_BLOCKED,
         ],
         [BlockListRouteName]: [],
-      }[routeName]),
+      })[routeName],
     [routeName],
   );
 
   const userInfos = useSelector(state => state.userStore.userInfos);
   const userInfosArray = React.useMemo(
     () =>
       values(userInfos).filter(userInfo => {
         const relationship = userInfo.relationshipStatus;
         return !excludeStatuses.includes(relationship);
       }),
     [userInfos, excludeStatuses],
   );
 
   const [searchInputText, setSearchInputText] = React.useState<string>('');
   const [userStoreSearchResults, setUserStoreSearchResults] = React.useState<
     $ReadOnlySet<string>,
   >(new Set());
 
   const serverSearchResults = useSearchUsers(searchInputText);
   const filteredServerSearchResults = React.useMemo(
     () =>
       serverSearchResults.filter(searchUserInfo => {
         const userInfo = userInfos[searchUserInfo.id];
         return (
           !userInfo || !excludeStatuses.includes(userInfo.relationshipStatus)
         );
       }),
     [serverSearchResults, userInfos, excludeStatuses],
   );
 
   const userStoreSearchIndex = useUserSearchIndex(userInfosArray);
   const onChangeSearchText = React.useCallback(
     async (searchText: string) => {
       setSearchInputText(searchText);
 
       const results = userStoreSearchIndex.getSearchResults(searchText);
       setUserStoreSearchResults(new Set(results));
     },
     [userStoreSearchIndex],
   );
 
   const overlayContext = React.useContext(OverlayContext);
   invariant(overlayContext, 'RelationshipList should have OverlayContext');
   const scrollEnabled = overlayContext.scrollBlockingModalStatus === 'closed';
 
   const tagInputRef = React.useRef<?BaseTagInput<GlobalAccountUserInfo>>();
   const flatListContainerRef = React.useRef<?React.ElementRef<typeof View>>();
 
   const keyboardState = React.useContext(KeyboardContext);
   const keyboardNotShowing = !!(
     keyboardState && !keyboardState.keyboardShowing
   );
   const [verticalBounds, setVerticalBounds] =
     React.useState<?VerticalBounds>(null);
   const onFlatListContainerLayout = React.useCallback(() => {
     if (!flatListContainerRef.current) {
       return;
     }
 
     if (!keyboardNotShowing) {
       return;
     }
 
     flatListContainerRef.current.measure(
       (x, y, width, height, pageX, pageY) => {
         if (
           height === null ||
           height === undefined ||
           pageY === null ||
           pageY === undefined
         ) {
           return;
         }
         setVerticalBounds({ height, y: pageY });
       },
     );
   }, [keyboardNotShowing]);
 
   const [currentTags, setCurrentTags] = React.useState<
     $ReadOnlyArray<GlobalAccountUserInfo>,
   >([]);
 
   const onSelect = React.useCallback(
     (selectedUser: GlobalAccountUserInfo) => {
       if (currentTags.find(o => o.id === selectedUser.id)) {
         return;
       }
       setSearchInputText('');
       setCurrentTags(prevCurrentTags => prevCurrentTags.concat(selectedUser));
     },
     [currentTags],
   );
 
   const onUnknownErrorAlertAcknowledged = React.useCallback(() => {
     setCurrentTags([]);
     setSearchInputText('');
     tagInputRef.current?.focus();
   }, []);
 
   const callUpdateRelationships = useServerCall(updateRelationships);
   const updateRelationshipsOnServer = React.useCallback(async () => {
     const action = {
       [FriendListRouteName]: relationshipActions.FRIEND,
       [BlockListRouteName]: relationshipActions.BLOCK,
     }[routeName];
     const userIDs = currentTags.map(userInfo => userInfo.id);
     try {
       const result = await callUpdateRelationships({
         action,
         userIDs,
       });
       setCurrentTags([]);
       setSearchInputText('');
       return result;
     } catch (e) {
       Alert.alert(
         'Unknown error',
         'Uhh... try again?',
         [{ text: 'OK', onPress: onUnknownErrorAlertAcknowledged }],
         { cancelable: true, onDismiss: onUnknownErrorAlertAcknowledged },
       );
       throw e;
     }
   }, [
     routeName,
     currentTags,
     callUpdateRelationships,
     onUnknownErrorAlertAcknowledged,
   ]);
 
   const dispatchActionPromise = useDispatchActionPromise();
   const noCurrentTags = currentTags.length === 0;
   const onPressAdd = React.useCallback(() => {
     if (noCurrentTags) {
       return;
     }
     void dispatchActionPromise(
       updateRelationshipsActionTypes,
       updateRelationshipsOnServer(),
     );
   }, [noCurrentTags, dispatchActionPromise, updateRelationshipsOnServer]);
   const inputProps = React.useMemo(
     () => ({
       ...tagInputProps,
       onSubmitEditing: onPressAdd,
     }),
     [onPressAdd],
   );
 
   const { navigation } = props;
   const { navigate } = navigation;
   const styles = useStyles(unboundStyles);
   const renderItem = React.useCallback(
     // ESLint doesn't recognize that invariant always throws
     // eslint-disable-next-line consistent-return
     ({ item }: { item: ListItem, ... }) => {
       if (item.type === 'empty') {
         const action = {
           [FriendListRouteName]: 'added',
           [BlockListRouteName]: 'blocked',
         }[routeName];
 
         const emptyMessage =
           item.because === 'no-relationships'
             ? `You haven't ${action} any users yet`
             : 'No results';
 
         return <Text style={styles.emptyText}>{emptyMessage}</Text>;
       } else if (item.type === 'header' || item.type === 'footer') {
         return <View style={styles.separator} />;
       } else if (item.type === 'user') {
         return (
           <RelationshipListItem
             userInfo={item.userInfo}
             lastListItem={item.lastListItem}
             verticalBounds={item.verticalBounds}
             navigate={navigate}
             relationshipListRoute={route}
             onSelect={onSelect}
           />
         );
       } else {
         invariant(false, `unexpected RelationshipList item type ${item.type}`);
       }
     },
     [routeName, navigate, route, onSelect, styles.emptyText, styles.separator],
   );
 
   const { setOptions } = navigation;
   const prevNoCurrentTags = React.useRef(noCurrentTags);
   React.useEffect(() => {
     let setSaveButtonDisabled;
     if (!prevNoCurrentTags.current && noCurrentTags) {
       setSaveButtonDisabled = true;
     } else if (prevNoCurrentTags.current && !noCurrentTags) {
       setSaveButtonDisabled = false;
     }
     prevNoCurrentTags.current = noCurrentTags;
     if (setSaveButtonDisabled === undefined) {
       return;
     }
     setOptions({
       // eslint-disable-next-line react/display-name
       headerRight: () => (
         <LinkButton
           text="Save"
           onPress={onPressAdd}
           disabled={setSaveButtonDisabled}
         />
       ),
     });
   }, [setOptions, noCurrentTags, onPressAdd]);
 
   const relationships = useSelector(userRelationshipsSelector);
   const viewerID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
   const usersWithoutENSNames = React.useMemo(() => {
     if (searchInputText === '') {
       return {
         [FriendListRouteName]: relationships.friends,
         [BlockListRouteName]: relationships.blocked,
       }[routeName];
     }
 
     const mergedUserInfos: { [id: string]: AccountUserInfo } = {};
     for (const userInfo of filteredServerSearchResults) {
       mergedUserInfos[userInfo.id] = userInfo;
     }
     for (const id of userStoreSearchResults) {
       const { username, relationshipStatus } = userInfos[id];
       if (username) {
         mergedUserInfos[id] = { id, username, relationshipStatus };
       }
     }
 
     const excludeUserIDsArray = currentTags
       .map(userInfo => userInfo.id)
       .concat(viewerID || []);
     const excludeUserIDs = new Set(excludeUserIDsArray);
 
     const sortToEnd = [];
     const userSearchResults = [];
     const sortRelationshipTypesToEnd = {
       [FriendListRouteName]: [userRelationshipStatus.FRIEND],
       [BlockListRouteName]: [
         userRelationshipStatus.BLOCKED_BY_VIEWER,
         userRelationshipStatus.BOTH_BLOCKED,
       ],
     }[routeName];
     for (const userID in mergedUserInfos) {
       if (excludeUserIDs.has(userID)) {
         continue;
       }
 
       const userInfo = mergedUserInfos[userID];
       if (sortRelationshipTypesToEnd.includes(userInfo.relationshipStatus)) {
         sortToEnd.push(userInfo);
       } else {
         userSearchResults.push(userInfo);
       }
     }
 
     return userSearchResults.concat(sortToEnd);
   }, [
     searchInputText,
     relationships,
     routeName,
     viewerID,
     currentTags,
     filteredServerSearchResults,
     userStoreSearchResults,
     userInfos,
   ]);
 
   const displayUsers = useENSNames(usersWithoutENSNames);
   const listData = React.useMemo(() => {
     let emptyItem;
     if (displayUsers.length === 0 && searchInputText === '') {
       emptyItem = { type: 'empty', because: 'no-relationships' };
     } else if (displayUsers.length === 0) {
       emptyItem = { type: 'empty', because: 'no-results' };
     }
 
     const mappedUsers = displayUsers.map((userInfo, index) => ({
       type: 'user',
       userInfo,
       lastListItem: displayUsers.length - 1 === index,
       verticalBounds,
     }));
 
     return []
       .concat(emptyItem ? emptyItem : [])
       .concat(emptyItem ? [] : { type: 'header' })
       .concat(mappedUsers)
       .concat(emptyItem ? [] : { type: 'footer' });
   }, [displayUsers, verticalBounds, searchInputText]);
 
   const indicatorStyle = useIndicatorStyle();
   const currentTagsWithENSNames = useENSNames(currentTags);
   return (
     <View style={styles.container}>
       <View style={styles.tagInputContainer}>
         <Text style={styles.tagInputLabel}>Search:</Text>
         <View style={styles.tagInput}>
           <TagInput
             value={currentTagsWithENSNames}
             onChange={setCurrentTags}
             text={searchInputText}
             onChangeText={onChangeSearchText}
             labelExtractor={tagDataLabelExtractor}
             ref={tagInputRef}
             inputProps={inputProps}
             maxHeight={36}
           />
         </View>
       </View>
       <View
         ref={flatListContainerRef}
         onLayout={onFlatListContainerLayout}
         style={styles.container}
       >
         <FlatList
           contentContainerStyle={styles.contentContainer}
           data={listData}
           renderItem={renderItem}
           keyExtractor={keyExtractor}
           scrollEnabled={scrollEnabled}
           indicatorStyle={indicatorStyle}
           keyboardShouldPersistTaps="handled"
         />
       </View>
     </View>
   );
 }
 
 const unboundStyles = {
   container: {
     flex: 1,
     backgroundColor: 'panelBackground',
   },
   contentContainer: {
     paddingTop: 12,
     paddingBottom: 24,
   },
   separator: {
     backgroundColor: 'panelForegroundBorder',
     height: Platform.OS === 'android' ? 1.5 : 1,
   },
   emptyText: {
     color: 'panelForegroundSecondaryLabel',
     flex: 1,
     fontSize: 16,
     lineHeight: 20,
     textAlign: 'center',
     paddingHorizontal: 12,
     paddingVertical: 10,
     marginHorizontal: 12,
   },
   tagInput: {
     flex: 1,
     marginLeft: 8,
     paddingRight: 12,
   },
   tagInputLabel: {
     color: 'panelForegroundTertiaryLabel',
     fontSize: 16,
     paddingLeft: 12,
   },
   tagInputContainer: {
     alignItems: 'center',
     backgroundColor: 'panelForeground',
     borderBottomWidth: 1,
     borderColor: 'panelForegroundBorder',
     flexDirection: 'row',
     paddingVertical: 6,
   },
 };
 
 registerFetchKey(updateRelationshipsActionTypes);
 
 const MemoizedRelationshipList: React.ComponentType<Props> =
   React.memo<Props>(RelationshipList);
 MemoizedRelationshipList.displayName = 'RelationshipList';
 
 export default MemoizedRelationshipList;
diff --git a/native/selectors/message-selectors.js b/native/selectors/message-selectors.js
index 300d5fae1..9e98710e8 100644
--- a/native/selectors/message-selectors.js
+++ b/native/selectors/message-selectors.js
@@ -1,70 +1,70 @@
 // @flow
 
 import { createSelector } from 'reselect';
 
 import { threadIsPending } from 'lib/shared/thread-utils.js';
 import type { ThreadMessageInfo } from 'lib/types/message-types.js';
 import { defaultNumberPerThread } from 'lib/types/message-types.js';
 import type { ThreadActivityStore } from 'lib/types/thread-activity-types.js';
 import type { RawThreadInfos } from 'lib/types/thread-types.js';
 
 import { activeThreadSelector } from '../navigation/nav-selectors.js';
 import type { AppState } from '../redux/state-types.js';
 import type { NavPlusRedux } from '../types/selector-types.js';
 
 const msInHour = 60 * 60 * 1000;
 
 const nextMessagePruneTimeSelector: (state: AppState) => ?number =
   createSelector(
     (state: AppState) => state.threadStore.threadInfos,
     (state: AppState) => state.threadActivityStore,
     (
       threadInfos: RawThreadInfos,
       threadActivityStore: ThreadActivityStore,
     ): ?number => {
       let nextTime;
       for (const threadID in threadInfos) {
         const threadPruneTime = Math.max(
           (threadActivityStore?.[threadID]?.lastNavigatedTo ?? 0) + msInHour,
           (threadActivityStore?.[threadID]?.lastPruned ?? 0) + msInHour * 6,
         );
         if (nextTime === undefined || threadPruneTime < nextTime) {
           nextTime = threadPruneTime;
         }
       }
       return nextTime;
     },
   );
 
 const pruneThreadIDsSelector: (
   input: NavPlusRedux,
 ) => () => $ReadOnlyArray<string> = createSelector(
   (input: NavPlusRedux): ThreadActivityStore => input.redux.threadActivityStore,
   (input: NavPlusRedux) => input.redux.messageStore.threads,
   (input: NavPlusRedux) => activeThreadSelector(input.navContext),
   (
-      threadActivityStore: ThreadActivityStore,
-      threadMessageInfos: { +[id: string]: ThreadMessageInfo },
-      activeThread: ?string,
-    ) =>
+    threadActivityStore: ThreadActivityStore,
+    threadMessageInfos: { +[id: string]: ThreadMessageInfo },
+    activeThread: ?string,
+  ) =>
     (): $ReadOnlyArray<string> => {
       const now = Date.now();
       const threadIDsToPrune = [];
       for (const threadID in threadMessageInfos) {
         if (threadID === activeThread || threadIsPending(threadID)) {
           continue;
         }
         const threadMessageInfo = threadMessageInfos[threadID];
         if (
           (threadActivityStore?.[threadID]?.lastNavigatedTo ?? 0) + msInHour <
             now &&
           threadMessageInfo.messageIDs.length > defaultNumberPerThread
         ) {
           threadIDsToPrune.push(threadID);
         }
       }
       return threadIDsToPrune;
     },
 );
 
 export { nextMessagePruneTimeSelector, pruneThreadIDsSelector };
diff --git a/native/selectors/socket-selectors.js b/native/selectors/socket-selectors.js
index 7c07aa153..660048f34 100644
--- a/native/selectors/socket-selectors.js
+++ b/native/selectors/socket-selectors.js
@@ -1,151 +1,151 @@
 // @flow
 
 import _memoize from 'lodash/memoize.js';
 import { createSelector } from 'reselect';
 
 import {
   cookieSelector,
   urlPrefixSelector,
 } from 'lib/selectors/keyserver-selectors.js';
 import {
   getClientResponsesSelector,
   sessionStateFuncSelector,
 } from 'lib/selectors/socket-selectors.js';
 import { createOpenSocketFunction } from 'lib/shared/socket-utils.js';
 import type { SignedIdentityKeysBlob } from 'lib/types/crypto-types.js';
 import type {
   ClientServerRequest,
   ClientClientResponse,
 } from 'lib/types/request-types.js';
 import type {
   SessionIdentification,
   SessionState,
 } from 'lib/types/session-types.js';
 import type { OneTimeKeyGenerator } from 'lib/types/socket-types.js';
 
 import { commCoreModule } from '../native-modules.js';
 import { calendarActiveSelector } from '../navigation/nav-selectors.js';
 import type { AppState } from '../redux/state-types.js';
 import type { NavPlusRedux } from '../types/selector-types.js';
 
 const baseOpenSocketSelector: (
   keyserverID: string,
 ) => (state: AppState) => ?() => WebSocket = keyserverID =>
   createSelector(
     urlPrefixSelector(keyserverID),
     // We don't actually use the cookie in the socket open function,
     // but we do use it in the initial message, and when the cookie changes
     // the socket needs to be reopened. By including the cookie here,
     // whenever the cookie changes this function will change,
     // which tells the Socket component to restart the connection.
     cookieSelector(keyserverID),
     (urlPrefix: ?string) => {
       if (!urlPrefix) {
         return null;
       }
       return createOpenSocketFunction(urlPrefix);
     },
   );
 
 const openSocketSelector: (
   keyserverID: string,
 ) => (state: AppState) => ?() => WebSocket = _memoize(baseOpenSocketSelector);
 
 const baseSessionIdentificationSelector: (
   keyserverID: string,
 ) => (state: AppState) => SessionIdentification = keyserverID =>
   createSelector(
     cookieSelector(keyserverID),
     (cookie: ?string): SessionIdentification => ({ cookie }),
   );
 
 const sessionIdentificationSelector: (
   keyserverID: string,
 ) => (state: AppState) => SessionIdentification = _memoize(
   baseSessionIdentificationSelector,
 );
 
 function oneTimeKeyGenerator(inc: number): string {
   // todo replace this hard code with something like
   // commCoreModule.generateOneTimeKeys()
   let str = Date.now().toString() + '_' + inc.toString() + '_';
   while (str.length < 43) {
     str += Math.random().toString(36).substr(2, 5);
   }
   str = str.substr(0, 43);
   return str;
 }
 
 async function getSignedIdentityKeysBlob(): Promise<SignedIdentityKeysBlob> {
   await commCoreModule.initializeCryptoAccount();
   const { blobPayload, signature } = await commCoreModule.getUserPublicKey();
   const signedIdentityKeysBlob: SignedIdentityKeysBlob = {
     payload: blobPayload,
     signature,
   };
   return signedIdentityKeysBlob;
 }
 
 type NativeGetClientResponsesSelectorInputType = {
   ...NavPlusRedux,
   getInitialNotificationsEncryptedMessage: () => Promise<string>,
 };
 
 const nativeGetClientResponsesSelector: (
   input: NativeGetClientResponsesSelectorInputType,
 ) => (
   serverRequests: $ReadOnlyArray<ClientServerRequest>,
 ) => Promise<$ReadOnlyArray<ClientClientResponse>> = createSelector(
   (input: NativeGetClientResponsesSelectorInputType) =>
     getClientResponsesSelector(input.redux),
   (input: NativeGetClientResponsesSelectorInputType) =>
     calendarActiveSelector(input.navContext),
   (input: NativeGetClientResponsesSelectorInputType) =>
     input.getInitialNotificationsEncryptedMessage,
   (
-      getClientResponsesFunc: (
-        calendarActive: boolean,
-        oneTimeKeyGenerator: ?OneTimeKeyGenerator,
-        getSignedIdentityKeysBlob: () => Promise<SignedIdentityKeysBlob>,
-        getInitialNotificationsEncryptedMessage: ?() => Promise<string>,
-        serverRequests: $ReadOnlyArray<ClientServerRequest>,
-      ) => Promise<$ReadOnlyArray<ClientClientResponse>>,
+    getClientResponsesFunc: (
       calendarActive: boolean,
-      getInitialNotificationsEncryptedMessage: () => Promise<string>,
-    ) =>
+      oneTimeKeyGenerator: ?OneTimeKeyGenerator,
+      getSignedIdentityKeysBlob: () => Promise<SignedIdentityKeysBlob>,
+      getInitialNotificationsEncryptedMessage: ?() => Promise<string>,
+      serverRequests: $ReadOnlyArray<ClientServerRequest>,
+    ) => Promise<$ReadOnlyArray<ClientClientResponse>>,
+    calendarActive: boolean,
+    getInitialNotificationsEncryptedMessage: () => Promise<string>,
+  ) =>
     (serverRequests: $ReadOnlyArray<ClientServerRequest>) =>
       getClientResponsesFunc(
         calendarActive,
         oneTimeKeyGenerator,
         getSignedIdentityKeysBlob,
         getInitialNotificationsEncryptedMessage,
         serverRequests,
       ),
 );
 
 const baseNativeSessionStateFuncSelector: (
   keyserverID: string,
 ) => (input: NavPlusRedux) => () => SessionState = keyserverID =>
   createSelector(
     (input: NavPlusRedux) => sessionStateFuncSelector(keyserverID)(input.redux),
     (input: NavPlusRedux) => calendarActiveSelector(input.navContext),
     (
-        sessionStateFunc: (calendarActive: boolean) => SessionState,
-        calendarActive: boolean,
-      ) =>
+      sessionStateFunc: (calendarActive: boolean) => SessionState,
+      calendarActive: boolean,
+    ) =>
       () =>
         sessionStateFunc(calendarActive),
   );
 
 const nativeSessionStateFuncSelector: (
   keyserverID: string,
 ) => (input: NavPlusRedux) => () => SessionState = _memoize(
   baseNativeSessionStateFuncSelector,
 );
 
 export {
   openSocketSelector,
   sessionIdentificationSelector,
   nativeGetClientResponsesSelector,
   nativeSessionStateFuncSelector,
 };
diff --git a/web/database/worker/db-worker.js b/web/database/worker/db-worker.js
index 0b2b6f60e..de512f5d4 100644
--- a/web/database/worker/db-worker.js
+++ b/web/database/worker/db-worker.js
@@ -1,266 +1,265 @@
 // @flow
 
 import localforage from 'localforage';
 
 import {
   getClientStore,
   processDBStoreOperations,
 } from './process-operations.js';
 import {
   decryptData,
   encryptData,
   generateCryptoKey,
   importJWKKey,
   type EncryptedData,
 } from '../../crypto/aes-gcm-crypto-utils.js';
 import {
   type SharedWorkerMessageEvent,
   type WorkerRequestMessage,
   type WorkerResponseMessage,
   workerRequestMessageTypes,
   workerResponseMessageTypes,
   type WorkerRequestProxyMessage,
   workerWriteRequests,
 } from '../../types/worker-types.js';
 import { getDatabaseModule } from '../db-module.js';
 import { type EmscriptenModule } from '../types/module.js';
 import { type SQLiteQueryExecutor } from '../types/sqlite-query-executor.js';
 import {
   COMM_SQLITE_DATABASE_PATH,
   CURRENT_USER_ID_KEY,
   localforageConfig,
   SQLITE_CONTENT,
   SQLITE_ENCRYPTION_KEY,
 } from '../utils/constants.js';
 import {
   clearSensitiveData,
   exportDatabaseContent,
   importDatabaseContent,
 } from '../utils/db-utils.js';
 
 localforage.config(localforageConfig);
 
 let encryptionKey: ?CryptoKey = null;
 
 let sqliteQueryExecutor: ?SQLiteQueryExecutor = null;
 let dbModule: ?EmscriptenModule = null;
 
 let persistNeeded: boolean = false;
 let persistInProgress: boolean = false;
 
 async function initDatabase(
   databaseModuleFilePath: string,
   commQueryExecutorFilename: ?string,
   encryptionKeyJWK?: ?SubtleCrypto$JsonWebKey,
 ) {
   if (!!dbModule && !!sqliteQueryExecutor) {
     console.log('Database already initialized');
     return;
   }
 
   const newModule = dbModule
     ? dbModule
     : getDatabaseModule(commQueryExecutorFilename, databaseModuleFilePath);
   if (!dbModule) {
     dbModule = newModule;
   }
 
   if (encryptionKeyJWK) {
     encryptionKey = await importJWKKey(encryptionKeyJWK);
   } else {
     encryptionKey = await localforage.getItem(SQLITE_ENCRYPTION_KEY);
     if (!encryptionKey) {
       const cryptoKey = await generateCryptoKey({ extractable: false });
       await localforage.setItem(SQLITE_ENCRYPTION_KEY, cryptoKey);
     }
   }
 
-  const encryptedContent = await localforage.getItem<EncryptedData>(
-    SQLITE_CONTENT,
-  );
+  const encryptedContent =
+    await localforage.getItem<EncryptedData>(SQLITE_CONTENT);
 
   let dbContent = null;
   try {
     if (encryptionKey && encryptedContent) {
       dbContent = await decryptData(encryptedContent, encryptionKey);
     }
   } catch (e) {
     console.error('Error while decrypting content, clearing database content');
     await localforage.removeItem(SQLITE_CONTENT);
   }
 
   if (dbContent) {
     importDatabaseContent(dbContent, newModule, COMM_SQLITE_DATABASE_PATH);
 
     console.info(
       'Database exists and is properly encrypted, using persisted data',
     );
   } else {
     console.info('Creating fresh database');
   }
   sqliteQueryExecutor = new newModule.SQLiteQueryExecutor(
     COMM_SQLITE_DATABASE_PATH,
   );
 }
 
 async function persist() {
   persistInProgress = true;
   const module = dbModule;
   if (!sqliteQueryExecutor || !module) {
     persistInProgress = false;
     throw new Error(
       'Database not initialized while persisting database content',
     );
   }
 
   if (!encryptionKey) {
     encryptionKey = await localforage.getItem(SQLITE_ENCRYPTION_KEY);
   }
 
   while (persistNeeded) {
     persistNeeded = false;
     const dbData = exportDatabaseContent(module, COMM_SQLITE_DATABASE_PATH);
     if (!encryptionKey) {
       persistInProgress = false;
       throw new Error('Encryption key is missing');
     }
     const encryptedData = await encryptData(dbData, encryptionKey);
     await localforage.setItem(SQLITE_CONTENT, encryptedData);
   }
   persistInProgress = false;
 }
 
 async function processAppRequest(
   message: WorkerRequestMessage,
 ): Promise<?WorkerResponseMessage> {
   // non-database operations
   if (message.type === workerRequestMessageTypes.PING) {
     return {
       type: workerResponseMessageTypes.PONG,
       text: 'PONG',
     };
   } else if (
     message.type === workerRequestMessageTypes.GENERATE_DATABASE_ENCRYPTION_KEY
   ) {
     const cryptoKey = await generateCryptoKey({ extractable: false });
     await localforage.setItem(SQLITE_ENCRYPTION_KEY, cryptoKey);
     return undefined;
   }
 
   // database operations
   if (message.type === workerRequestMessageTypes.INIT) {
     await initDatabase(
       message.databaseModuleFilePath,
       message.commQueryExecutorFilename,
       message.encryptionKey,
     );
     return undefined;
   } else if (message.type === workerRequestMessageTypes.CLEAR_SENSITIVE_DATA) {
     encryptionKey = null;
     await localforage.clear();
     if (dbModule && sqliteQueryExecutor) {
       clearSensitiveData(
         dbModule,
         COMM_SQLITE_DATABASE_PATH,
         sqliteQueryExecutor,
       );
     }
     sqliteQueryExecutor = null;
     return undefined;
   }
 
   if (!sqliteQueryExecutor) {
     throw new Error(
       `Database not initialized, unable to process request type: ${message.type}`,
     );
   }
 
   // read-only operations
   if (message.type === workerRequestMessageTypes.GET_CLIENT_STORE) {
     return {
       type: workerResponseMessageTypes.CLIENT_STORE,
       store: getClientStore(sqliteQueryExecutor),
     };
   } else if (message.type === workerRequestMessageTypes.GET_CURRENT_USER_ID) {
     return {
       type: workerResponseMessageTypes.GET_CURRENT_USER_ID,
       userID: sqliteQueryExecutor.getMetadata(CURRENT_USER_ID_KEY),
     };
   } else if (
     message.type === workerRequestMessageTypes.GET_PERSIST_STORAGE_ITEM
   ) {
     return {
       type: workerResponseMessageTypes.GET_PERSIST_STORAGE_ITEM,
       item: sqliteQueryExecutor.getPersistStorageItem(message.key),
     };
   }
 
   // write operations
   if (!workerWriteRequests.includes(message.type)) {
     throw new Error('Request type not supported');
   }
   if (!sqliteQueryExecutor || !dbModule) {
     throw new Error(
       `Database not initialized, unable to process request type: ${message.type}`,
     );
   }
 
   if (message.type === workerRequestMessageTypes.PROCESS_STORE_OPERATIONS) {
     processDBStoreOperations(
       sqliteQueryExecutor,
       message.storeOperations,
       dbModule,
     );
   } else if (message.type === workerRequestMessageTypes.SET_CURRENT_USER_ID) {
     sqliteQueryExecutor.setMetadata(CURRENT_USER_ID_KEY, message.userID);
   } else if (
     message.type === workerRequestMessageTypes.SET_PERSIST_STORAGE_ITEM
   ) {
     sqliteQueryExecutor.setPersistStorageItem(message.key, message.item);
   } else if (
     message.type === workerRequestMessageTypes.REMOVE_PERSIST_STORAGE_ITEM
   ) {
     sqliteQueryExecutor.removePersistStorageItem(message.key);
   }
 
   persistNeeded = true;
   if (!persistInProgress) {
     void persist();
   }
 
   return undefined;
 }
 
 function connectHandler(event: SharedWorkerMessageEvent) {
   if (!event.ports.length) {
     return;
   }
   const port: MessagePort = event.ports[0];
   console.log('Web database worker alive!');
 
   port.onmessage = async function (messageEvent: MessageEvent) {
     const data: WorkerRequestProxyMessage = (messageEvent.data: any);
     const { id, message } = data;
 
     if (!id) {
       port.postMessage({
         error: 'Request without identifier',
       });
     }
 
     try {
       const result = await processAppRequest(message);
       port.postMessage({
         id,
         message: result,
       });
     } catch (e) {
       port.postMessage({
         id,
         error: e.message,
       });
     }
   };
 }
 
 self.addEventListener('connect', connectHandler);
diff --git a/web/push-notif/notif-crypto-utils.js b/web/push-notif/notif-crypto-utils.js
index 53fa7697e..3bdd009aa 100644
--- a/web/push-notif/notif-crypto-utils.js
+++ b/web/push-notif/notif-crypto-utils.js
@@ -1,375 +1,374 @@
 // @flow
 
 import olm from '@commapp/olm';
 import localforage from 'localforage';
 
 import {
   olmEncryptedMessageTypes,
   type NotificationsOlmDataType,
 } from 'lib/types/crypto-types.js';
 import type {
   PlainTextWebNotification,
   EncryptedWebNotification,
 } from 'lib/types/notif-types.js';
 import { getCookieIDFromCookie } from 'lib/utils/cookie-utils.js';
 
 import {
   type EncryptedData,
   decryptData,
   encryptData,
   importJWKKey,
 } from '../crypto/aes-gcm-crypto-utils.js';
 import {
   NOTIFICATIONS_OLM_DATA_CONTENT,
   NOTIFICATIONS_OLM_DATA_ENCRYPTION_KEY,
 } from '../database/utils/constants.js';
 import { isDesktopSafari } from '../database/utils/db-utils.js';
 import { initOlm } from '../olm/olm-utils.js';
 
 export type WebNotifDecryptionError = {
   +id: string,
   +error: string,
   +displayErrorMessage?: boolean,
 };
 
 export type WebNotifsServiceUtilsData = {
   +olmWasmPath: string,
   +staffCanSee: boolean,
 };
 
 type DecryptionResult<T> = {
   +newPendingSessionUpdate: string,
   +newUpdateCreationTimestamp: number,
   +decryptedNotification: T,
 };
 
 export const WEB_NOTIFS_SERVICE_UTILS_KEY = 'webNotifsServiceUtils';
 
 const SESSION_UPDATE_MAX_PENDING_TIME = 10 * 1000;
 
 async function decryptWebNotification(
   encryptedNotification: EncryptedWebNotification,
 ): Promise<PlainTextWebNotification | WebNotifDecryptionError> {
   const { id, encryptedPayload } = encryptedNotification;
   const utilsData = await localforage.getItem<WebNotifsServiceUtilsData>(
     WEB_NOTIFS_SERVICE_UTILS_KEY,
   );
 
   if (!utilsData) {
     return { id, error: 'Necessary data not found in IndexedDB' };
   }
   const { olmWasmPath, staffCanSee } = (utilsData: WebNotifsServiceUtilsData);
 
   let olmDBKeys;
   try {
     olmDBKeys = await getNotifsOlmSessionDBKeys();
   } catch (e) {
     return {
       id,
       error: e.message,
       displayErrorMessage: staffCanSee,
     };
   }
   const { olmDataContentKey, encryptionKeyDBKey } = olmDBKeys;
   const [encryptedOlmData, encryptionKey] = await Promise.all([
     localforage.getItem<EncryptedData>(olmDataContentKey),
     retrieveEncryptionKey(encryptionKeyDBKey),
   ]);
 
   if (!encryptionKey || !encryptedOlmData) {
     return {
       id,
       error: 'Received encrypted notification but olm session was not created',
       displayErrorMessage: staffCanSee,
     };
   }
 
   try {
     await olm.init({ locateFile: () => olmWasmPath });
 
     const decryptedNotification = await commonDecrypt<PlainTextWebNotification>(
       encryptedOlmData,
       olmDataContentKey,
       encryptionKey,
       encryptedPayload,
     );
 
     return { id, ...decryptedNotification };
   } catch (e) {
     return {
       id,
       error: e.message,
       displayErrorMessage: staffCanSee,
     };
   }
 }
 
 async function decryptDesktopNotification(
   encryptedPayload: string,
   staffCanSee: boolean,
 ): Promise<{ +[string]: mixed }> {
   let encryptedOlmData, encryptionKey, olmDataContentKey;
   try {
     const { olmDataContentKey: olmDataContentKeyValue, encryptionKeyDBKey } =
       await getNotifsOlmSessionDBKeys();
 
     olmDataContentKey = olmDataContentKeyValue;
 
     [encryptedOlmData, encryptionKey] = await Promise.all([
       localforage.getItem<EncryptedData>(olmDataContentKey),
       retrieveEncryptionKey(encryptionKeyDBKey),
       initOlm(),
     ]);
   } catch (e) {
     return {
       error: e.message,
       displayErrorMessage: staffCanSee,
     };
   }
 
   if (!encryptionKey || !encryptedOlmData) {
     return {
       error: 'Received encrypted notification but olm session was not created',
       displayErrorMessage: staffCanSee,
     };
   }
 
   try {
     return await commonDecrypt(
       encryptedOlmData,
       olmDataContentKey,
       encryptionKey,
       encryptedPayload,
     );
   } catch (e) {
     return {
       error: e.message,
       staffCanSee,
     };
   }
 }
 
 async function commonDecrypt<T>(
   encryptedOlmData: EncryptedData,
   olmDataContentKey: string,
   encryptionKey: CryptoKey,
   encryptedPayload: string,
 ): Promise<T> {
   const serializedOlmData = await decryptData(encryptedOlmData, encryptionKey);
   const {
     mainSession,
     picklingKey,
     pendingSessionUpdate,
     updateCreationTimestamp,
   }: NotificationsOlmDataType = JSON.parse(
     new TextDecoder().decode(serializedOlmData),
   );
 
   let updatedOlmData: NotificationsOlmDataType;
   let decryptedNotification: T;
 
   const shouldUpdateMainSession =
     Date.now() - updateCreationTimestamp > SESSION_UPDATE_MAX_PENDING_TIME;
 
   const decryptionWithPendingSessionResult = decryptWithPendingSession<T>(
     pendingSessionUpdate,
     picklingKey,
     encryptedPayload,
   );
 
   if (decryptionWithPendingSessionResult.decryptedNotification) {
     const {
       decryptedNotification: notifDecryptedWithPendingSession,
       newPendingSessionUpdate,
       newUpdateCreationTimestamp,
     } = decryptionWithPendingSessionResult;
 
     decryptedNotification = notifDecryptedWithPendingSession;
     updatedOlmData = {
       mainSession: shouldUpdateMainSession ? pendingSessionUpdate : mainSession,
       pendingSessionUpdate: newPendingSessionUpdate,
       updateCreationTimestamp: newUpdateCreationTimestamp,
       picklingKey,
     };
   } else {
     const {
       newUpdateCreationTimestamp,
       decryptedNotification: notifDecryptedWithMainSession,
     } = decryptWithSession<T>(mainSession, picklingKey, encryptedPayload);
 
     decryptedNotification = notifDecryptedWithMainSession;
     updatedOlmData = {
       mainSession: mainSession,
       pendingSessionUpdate,
       updateCreationTimestamp: newUpdateCreationTimestamp,
       picklingKey,
     };
   }
 
   const updatedEncryptedSession = await encryptData(
     new TextEncoder().encode(JSON.stringify(updatedOlmData)),
     encryptionKey,
   );
 
   await localforage.setItem(olmDataContentKey, updatedEncryptedSession);
 
   return decryptedNotification;
 }
 
 function decryptWithSession<T>(
   pickledSession: string,
   picklingKey: string,
   encryptedPayload: string,
 ): DecryptionResult<T> {
   const session = new olm.Session();
 
   session.unpickle(picklingKey, pickledSession);
   const decryptedNotification: T = JSON.parse(
     session.decrypt(olmEncryptedMessageTypes.TEXT, encryptedPayload),
   );
 
   const newPendingSessionUpdate = session.pickle(picklingKey);
   const newUpdateCreationTimestamp = Date.now();
 
   return {
     decryptedNotification,
     newUpdateCreationTimestamp,
     newPendingSessionUpdate,
   };
 }
 
 function decryptWithPendingSession<T>(
   pendingSessionUpdate: string,
   picklingKey: string,
   encryptedPayload: string,
 ): DecryptionResult<T> | { +error: string } {
   try {
     const {
       decryptedNotification,
       newPendingSessionUpdate,
       newUpdateCreationTimestamp,
     } = decryptWithSession<T>(
       pendingSessionUpdate,
       picklingKey,
       encryptedPayload,
     );
     return {
       newPendingSessionUpdate,
       newUpdateCreationTimestamp,
       decryptedNotification,
     };
   } catch (e) {
     return { error: e.message };
   }
 }
 
 async function retrieveEncryptionKey(
   encryptionKeyDBLabel: string,
 ): Promise<?CryptoKey> {
   if (!isDesktopSafari) {
     return await localforage.getItem<CryptoKey>(encryptionKeyDBLabel);
   }
   // Safari doesn't support structured clone algorithm in service
   // worker context so we have to store CryptoKey as JSON
-  const persistedCryptoKey = await localforage.getItem<SubtleCrypto$JsonWebKey>(
-    encryptionKeyDBLabel,
-  );
+  const persistedCryptoKey =
+    await localforage.getItem<SubtleCrypto$JsonWebKey>(encryptionKeyDBLabel);
   if (!persistedCryptoKey) {
     return null;
   }
   return await importJWKKey(persistedCryptoKey);
 }
 
 async function getNotifsOlmSessionDBKeys(): Promise<{
   +olmDataContentKey: string,
   +encryptionKeyDBKey: string,
 }> {
   const dbKeys = await localforage.keys();
   const olmDataContentKeys = sortOlmDBKeysArray(
     dbKeys.filter(key => key.startsWith(NOTIFICATIONS_OLM_DATA_CONTENT)),
   );
   const encryptionKeyDBLabels = sortOlmDBKeysArray(
     dbKeys.filter(key => key.startsWith(NOTIFICATIONS_OLM_DATA_ENCRYPTION_KEY)),
   );
 
   if (olmDataContentKeys.length === 0 || encryptionKeyDBLabels.length === 0) {
     throw new Error(
       'Received encrypted notification but olm session was not created',
     );
   }
 
   const latestDataContentKey =
     olmDataContentKeys[olmDataContentKeys.length - 1];
   const latestEncryptionKeyDBKey =
     encryptionKeyDBLabels[encryptionKeyDBLabels.length - 1];
 
   const latestDataContentCookieID =
     getCookieIDFromOlmDBKey(latestDataContentKey);
   const latestEncryptionKeyCookieID = getCookieIDFromOlmDBKey(
     latestEncryptionKeyDBKey,
   );
 
   if (latestDataContentCookieID !== latestEncryptionKeyCookieID) {
     throw new Error(
       'Olm sessions and their encryption keys out of sync. Latest cookie ' +
         `id for olm sessions ${latestDataContentCookieID}. Latest cookie ` +
         `id for olm session encryption keys ${latestEncryptionKeyCookieID}`,
     );
   }
 
   const olmDBKeys = {
     olmDataContentKey: latestDataContentKey,
     encryptionKeyDBKey: latestEncryptionKeyDBKey,
   };
 
   const keysToDelete: $ReadOnlyArray<string> = [
     ...olmDataContentKeys.slice(0, olmDataContentKeys.length - 1),
     ...encryptionKeyDBLabels.slice(0, encryptionKeyDBLabels.length - 1),
   ];
 
   await Promise.all(keysToDelete.map(key => localforage.removeItem(key)));
   return olmDBKeys;
 }
 
 function getOlmDataContentKeyForCookie(cookie: ?string): string {
   if (!cookie) {
     return NOTIFICATIONS_OLM_DATA_CONTENT;
   }
   const cookieID = getCookieIDFromCookie(cookie);
   return `${NOTIFICATIONS_OLM_DATA_CONTENT}:${cookieID}`;
 }
 
 function getOlmEncryptionKeyDBLabelForCookie(cookie: ?string): string {
   if (!cookie) {
     return NOTIFICATIONS_OLM_DATA_ENCRYPTION_KEY;
   }
   const cookieID = getCookieIDFromCookie(cookie);
   return `${NOTIFICATIONS_OLM_DATA_ENCRYPTION_KEY}:${cookieID}`;
 }
 
 function getCookieIDFromOlmDBKey(olmDBKey: string): string | '0' {
   const cookieID = olmDBKey.split(':')[1];
   return cookieID ?? '0';
 }
 
 function sortOlmDBKeysArray(
   olmDBKeysArray: $ReadOnlyArray<string>,
 ): $ReadOnlyArray<string> {
   return olmDBKeysArray
     .map(key => ({
       cookieID: Number(getCookieIDFromOlmDBKey(key)),
       key,
     }))
     .sort(
       ({ cookieID: cookieID1 }, { cookieID: cookieID2 }) =>
         cookieID1 - cookieID2,
     )
     .map(({ key }) => key);
 }
 
 export {
   decryptWebNotification,
   decryptDesktopNotification,
   getOlmDataContentKeyForCookie,
   getOlmEncryptionKeyDBLabelForCookie,
 };
diff --git a/web/selectors/account-selectors.js b/web/selectors/account-selectors.js
index 3e6940822..0a9dfbb46 100644
--- a/web/selectors/account-selectors.js
+++ b/web/selectors/account-selectors.js
@@ -1,22 +1,22 @@
 // @flow
 
 import { createSelector } from 'reselect';
 
 import { logInExtraInfoSelector } from 'lib/selectors/account-selectors.js';
 import type { LogInExtraInfo } from 'lib/types/account-types.js';
 
 import type { AppState } from '../redux/redux-setup.js';
 
 const webLogInExtraInfoSelector: (state: AppState) => () => LogInExtraInfo =
   createSelector(
     logInExtraInfoSelector,
     (state: AppState) => state.navInfo.tab === 'calendar',
     (
-        logInExtraInfoFunc: (calendarActive: boolean) => LogInExtraInfo,
-        calendarActive: boolean,
-      ) =>
+      logInExtraInfoFunc: (calendarActive: boolean) => LogInExtraInfo,
+      calendarActive: boolean,
+    ) =>
       () =>
         logInExtraInfoFunc(calendarActive),
   );
 
 export { webLogInExtraInfoSelector };
diff --git a/web/selectors/nav-selectors.js b/web/selectors/nav-selectors.js
index e38556575..571f2b4cb 100644
--- a/web/selectors/nav-selectors.js
+++ b/web/selectors/nav-selectors.js
@@ -1,140 +1,140 @@
 // @flow
 
 import invariant from 'invariant';
 import { createSelector } from 'reselect';
 
 import { nonThreadCalendarFiltersSelector } from 'lib/selectors/calendar-filter-selectors.js';
 import { currentCalendarQuery } from 'lib/selectors/nav-selectors.js';
 import type { CalendarQuery } from 'lib/types/entry-types.js';
 import type { CalendarFilter } from 'lib/types/filter-types.js';
 
 import type { AppState } from '../redux/redux-setup.js';
 import {
   type NavigationTab,
   type NavigationSettingsSection,
 } from '../types/nav-types.js';
 
 const dateExtractionRegex = /^([0-9]{4})-([0-9]{2})-[0-9]{2}$/;
 
 function yearExtractor(startDate: string, endDate: string): ?number {
   const startDateResults = dateExtractionRegex.exec(startDate);
   const endDateResults = dateExtractionRegex.exec(endDate);
   if (
     !startDateResults ||
     !startDateResults[1] ||
     !endDateResults ||
     !endDateResults[1] ||
     startDateResults[1] !== endDateResults[1]
   ) {
     return null;
   }
   return parseInt(startDateResults[1], 10);
 }
 
 function yearAssertingExtractor(startDate: string, endDate: string): number {
   const result = yearExtractor(startDate, endDate);
   invariant(
     result !== null && result !== undefined,
     `${startDate} and ${endDate} aren't in the same year`,
   );
   return result;
 }
 
 const yearAssertingSelector: (state: AppState) => number = createSelector(
   (state: AppState) => state.navInfo.startDate,
   (state: AppState) => state.navInfo.endDate,
   yearAssertingExtractor,
 );
 
 // 1-indexed
 function monthExtractor(startDate: string, endDate: string): ?number {
   const startDateResults = dateExtractionRegex.exec(startDate);
   const endDateResults = dateExtractionRegex.exec(endDate);
   if (
     !startDateResults ||
     !startDateResults[1] ||
     !startDateResults[2] ||
     !endDateResults ||
     !endDateResults[1] ||
     !endDateResults[2] ||
     startDateResults[1] !== endDateResults[1] ||
     startDateResults[2] !== endDateResults[2]
   ) {
     return null;
   }
   return parseInt(startDateResults[2], 10);
 }
 
 // 1-indexed
 function monthAssertingExtractor(startDate: string, endDate: string): number {
   const result = monthExtractor(startDate, endDate);
   invariant(
     result !== null && result !== undefined,
     `${startDate} and ${endDate} aren't in the same month`,
   );
   return result;
 }
 
 // 1-indexed
 const monthAssertingSelector: (state: AppState) => number = createSelector(
   (state: AppState) => state.navInfo.startDate,
   (state: AppState) => state.navInfo.endDate,
   monthAssertingExtractor,
 );
 
 function activeThreadSelector(state: AppState): ?string {
   return state.navInfo.tab === 'chat' ? state.navInfo.activeChatThreadID : null;
 }
 
 const webCalendarQuery: (state: AppState) => () => CalendarQuery =
   createSelector(
     currentCalendarQuery,
     (state: AppState) => state.navInfo.tab === 'calendar',
     (
-        calendarQuery: (calendarActive: boolean) => CalendarQuery,
-        calendarActive: boolean,
-      ) =>
+      calendarQuery: (calendarActive: boolean) => CalendarQuery,
+      calendarActive: boolean,
+    ) =>
       () =>
         calendarQuery(calendarActive),
   );
 
 const nonThreadCalendarQuery: (state: AppState) => () => CalendarQuery =
   createSelector(
     webCalendarQuery,
     nonThreadCalendarFiltersSelector,
     (
       calendarQuery: () => CalendarQuery,
       filters: $ReadOnlyArray<CalendarFilter>,
     ) => {
       return (): CalendarQuery => {
         const query = calendarQuery();
         return {
           startDate: query.startDate,
           endDate: query.endDate,
           filters,
         };
       };
     },
   );
 
 function navTabSelector(state: AppState): NavigationTab {
   return state.navInfo.tab;
 }
 
 function navSettingsSectionSelector(
   state: AppState,
 ): ?NavigationSettingsSection {
   return state.navInfo.settingsSection;
 }
 
 export {
   yearExtractor,
   yearAssertingSelector,
   monthExtractor,
   monthAssertingSelector,
   activeThreadSelector,
   webCalendarQuery,
   nonThreadCalendarQuery,
   navTabSelector,
   navSettingsSectionSelector,
 };
diff --git a/web/selectors/socket-selectors.js b/web/selectors/socket-selectors.js
index c0aef6898..916cec01c 100644
--- a/web/selectors/socket-selectors.js
+++ b/web/selectors/socket-selectors.js
@@ -1,127 +1,127 @@
 // @flow
 
 import _memoize from 'lodash/memoize.js';
 import { createSelector } from 'reselect';
 
 import {
   sessionIDSelector,
   urlPrefixSelector,
   cookieSelector,
 } from 'lib/selectors/keyserver-selectors.js';
 import {
   getClientResponsesSelector,
   sessionStateFuncSelector,
 } from 'lib/selectors/socket-selectors.js';
 import { createOpenSocketFunction } from 'lib/shared/socket-utils.js';
 import type { SignedIdentityKeysBlob } from 'lib/types/crypto-types.js';
 import type {
   ClientServerRequest,
   ClientClientResponse,
 } from 'lib/types/request-types.js';
 import type {
   SessionIdentification,
   SessionState,
 } from 'lib/types/session-types.js';
 import type { OneTimeKeyGenerator } from 'lib/types/socket-types.js';
 
 import type { AppState } from '../redux/redux-setup.js';
 
 const baseOpenSocketSelector: (
   keyserverID: string,
 ) => (state: AppState) => ?() => WebSocket = keyserverID =>
   createSelector(urlPrefixSelector(keyserverID), (urlPrefix: ?string) => {
     if (!urlPrefix) {
       return null;
     }
     return createOpenSocketFunction(urlPrefix);
   });
 
 const openSocketSelector: (
   keyserverID: string,
 ) => (state: AppState) => ?() => WebSocket = _memoize(baseOpenSocketSelector);
 
 const baseSessionIdentificationSelector: (
   keyserverID: string,
 ) => (state: AppState) => SessionIdentification = keyserverID =>
   createSelector(
     cookieSelector(keyserverID),
     sessionIDSelector(keyserverID),
     (cookie: ?string, sessionID: ?string): SessionIdentification => ({
       cookie,
       sessionID,
     }),
   );
 
 const sessionIdentificationSelector: (
   keyserverID: string,
 ) => (state: AppState) => SessionIdentification = _memoize(
   baseSessionIdentificationSelector,
 );
 
 type WebGetClientResponsesSelectorInputType = {
   +state: AppState,
   +getSignedIdentityKeysBlob: () => Promise<SignedIdentityKeysBlob>,
   +getInitialNotificationsEncryptedMessage: () => Promise<string>,
 };
 
 const webGetClientResponsesSelector: (
   input: WebGetClientResponsesSelectorInputType,
 ) => (
   serverRequests: $ReadOnlyArray<ClientServerRequest>,
 ) => Promise<$ReadOnlyArray<ClientClientResponse>> = createSelector(
   (input: WebGetClientResponsesSelectorInputType) =>
     getClientResponsesSelector(input.state),
   (input: WebGetClientResponsesSelectorInputType) =>
     input.getSignedIdentityKeysBlob,
   (input: WebGetClientResponsesSelectorInputType) =>
     input.state.navInfo.tab === 'calendar',
   (input: WebGetClientResponsesSelectorInputType) =>
     input.getInitialNotificationsEncryptedMessage,
   (
-      getClientResponsesFunc: (
-        calendarActive: boolean,
-        oneTimeKeyGenerator: ?OneTimeKeyGenerator,
-        getSignedIdentityKeysBlob: () => Promise<SignedIdentityKeysBlob>,
-        getInitialNotificationsEncryptedMessage: () => Promise<string>,
-        serverRequests: $ReadOnlyArray<ClientServerRequest>,
-      ) => Promise<$ReadOnlyArray<ClientClientResponse>>,
-      getSignedIdentityKeysBlob: () => Promise<SignedIdentityKeysBlob>,
+    getClientResponsesFunc: (
       calendarActive: boolean,
+      oneTimeKeyGenerator: ?OneTimeKeyGenerator,
+      getSignedIdentityKeysBlob: () => Promise<SignedIdentityKeysBlob>,
       getInitialNotificationsEncryptedMessage: () => Promise<string>,
-    ) =>
+      serverRequests: $ReadOnlyArray<ClientServerRequest>,
+    ) => Promise<$ReadOnlyArray<ClientClientResponse>>,
+    getSignedIdentityKeysBlob: () => Promise<SignedIdentityKeysBlob>,
+    calendarActive: boolean,
+    getInitialNotificationsEncryptedMessage: () => Promise<string>,
+  ) =>
     (serverRequests: $ReadOnlyArray<ClientServerRequest>) =>
       getClientResponsesFunc(
         calendarActive,
         null,
         getSignedIdentityKeysBlob,
         getInitialNotificationsEncryptedMessage,
         serverRequests,
       ),
 );
 
 const baseWebSessionStateFuncSelector: (
   keyserverID: string,
 ) => (state: AppState) => () => SessionState = keyserverID =>
   createSelector(
     sessionStateFuncSelector(keyserverID),
     (state: AppState) => state.navInfo.tab === 'calendar',
     (
-        sessionStateFunc: (calendarActive: boolean) => SessionState,
-        calendarActive: boolean,
-      ) =>
+      sessionStateFunc: (calendarActive: boolean) => SessionState,
+      calendarActive: boolean,
+    ) =>
       () =>
         sessionStateFunc(calendarActive),
   );
 
 const webSessionStateFuncSelector: (
   keyserverID: string,
 ) => (state: AppState) => () => SessionState = _memoize(
   baseWebSessionStateFuncSelector,
 );
 
 export {
   openSocketSelector,
   sessionIdentificationSelector,
   webGetClientResponsesSelector,
   webSessionStateFuncSelector,
 };